Every era stacks on the one before — nothing is removed. Know this arc to reason about what to use, where, and why.
🔑 Core Principle
Each era added a capability without erasing the previous ones. Today's production agents still use rules, ML models, transformers, and RAG — all at once. You are adding a reasoning layer on top, not replacing what already works.
1948 – 2000sEra 1 Rule-Based AI
Capability: Follow rules humans wrote. Period.
UCC: 500+ hand-written rules — IF filing_type=UCC1 AND days_to_lapse<90 THEN risk=HIGH. Every state format change broke the rulebook.
Talking Point
"Brittle — every edge case needed a new rule. Couldn't handle ambiguity or natural language. Worked for narrow problems; broke everywhere else."
2000s – 2015Era 2 Machine Learning
+ Learn patterns from data. Classification, prediction, clustering.
UCC: Random Forest trained on 10K historical filings. Input: 6 numbers → Output: delinquency probability. Same pickle model used in this course's Prelude.
Talking Point
"ML learns, but each model does ONE task. Can't reason, can't explain, needs structured features — can't read collateral descriptions or hold a conversation."
2017 – 2020Era 3 Transformers
+ Understand context. Process unstructured text. Generate coherent language.
UCC: NLP model reads collateral text — "All inventory, equipment, and accounts receivable now owned or hereafter acquired" — classifies into categories with no hand-built dictionary.
Talking Point
"Transformers solved the context problem. GPT-3 showed one model could do many tasks via prompting — that discovery built the next era."
2020 – 2023Era 4 Generative AI
+ Create content. Shift from understanding to generating.
UCC: Claude reads a 12-page filing and generates a summary, answers questions, drafts a risk memo, translates legal language — all from one model. ChatGPT hit 100M users in 2 months.
Talking Point
"Generative AI was the breakthrough for everyone. But it's reactive — responds to prompts. Can't search databases or call APIs. That gap is what agents fill."
2023 – 2024Era 5 LLMs Mature
+ RAG solves hallucination; tiered models solve cost. LLMs go from demos to production.
UCC: A bank deploys Claude with RAG over filing docs. Analysts ask questions grounded in real data — not hallucinated. But each question is still one prompt → one response. No loop, no agent.
Talking Point
"LLMs went from experiments to production. Haiku/Sonnet/Opus solved the cost problem. Limitation stayed: LLMs respond, they don't ACT."
2024 – presentEra 6 ★ Agentic AI
+ Take actions. LLM + tools + loop + memory = agent that REASONS and ACTS.
UCC: Agent searches filings across 50 states, discovers name variations by reasoning, calls the ML model, drills into the riskiest lien, writes a narrative report. This is what you'll build.
Talking Point
"Five things matured simultaneously: tool-use APIs, structured output, 200K context, fast inference, 240× cost drop. None existed in 2022. All exist now."
UCC: Agent drives the secretary-of-state portal directly, OCRs scanned filings, hands sub-tasks to a sibling agent in another business unit that owns "collateral classification."
Talking Point
"MCP standardizes agent-to-tool (Anthropic, 2024). A2A standardizes agent-to-agent (Google → Linux Foundation, 2025). Enterprises are starting to treat agents as part of the org chart."
§2
Why Agents Are Possible NOW
The headline isn't a smarter model — it's the scaffolding around the model. Five capabilities converged.
Capability
2022 (Impossible)
2026 (Production-Ready)
Why It Matters
Tool Use API
Did not exist
Native in Claude, GPT, Gemini
Agent can call functions reliably with typed inputs
Structured Output
Unreliable prompt-based JSON
Guaranteed via tool_use schema
Agent returns parseable, validated data
Context Window
4K – 8K tokens
200K (Claude), 1M+ (Gemini)
Holds long conversations + many tool results
Inference Speed
10 – 30 seconds
1 – 3 seconds per turn
Multi-turn loop completes in reasonable time
Cost per Token
$0.06 / 1K (GPT-3)
$0.00025 / 1K (Claude 3 Haiku, 2024)
240× cheaper — agent loops are finally affordable
💡
The One-Sentence Summary
"Five years ago you could build a chatbot. Today you can build an agent. The difference isn't a smarter model — it's the tools, context, speed, and cost around the model."
§3
Three Approaches — Same Problem, Smarter Output
Business question: "Is Acme Corporation likely to become delinquent in the next 12 months?" Three ways to answer it.
Approach 1 · Script
15 lines · ~$0 · Pure ML
InputYou manually compute 6 numbers and hand them to the function
Logicpredict_delinquency() → Random Forest model
Output0.823 probability. No explanation. No context.
Name var.Not handled — you must know the exact name
Follow-upWrite new code
Wins only when the task is 100% deterministic and speed matters most.
Approach 2 · FastAPI
35 lines · ~$0 · ML inside REST
InputPOST {"name": "Acme Corp"} — auto-fetches data
LogicHardcoded ILIKE SQL → compute features → ML
Output{"score": 0.823} — missed 4 filings with DBA names
Name var.Hardcoded ILIKE only — misses DBA variations
Follow-upBuild a new endpoint
Better than script, but rigid. New question = new endpoint.
Approach 3 · Agent ★
70 lines · ~$0.05 · 3 tools + reasoning
InputPlain English: "How risky is Acme Corporation?"
The ML model didn't disappear — the agent USES it. Same tool, smarter wrapper.
🔑 Key Insight
In Approach 1 the model is the product. In Approach 3 the model is one tool the agent calls when it needs a probability. The agent surrounds the model with reasoning, search, and narrative — making it more useful, not less. Every ML model your team has shipped can become an agent tool tomorrow.
§4
What IS and ISN'T an Agent
The boundary comes down to one question: who decides what happens next — your code, or Claude?
LEVEL 1
LLM Call
NOT an agent
How many LLM calls?Exactly 1
Uses tools?No
Has a loop?No
Adapts at runtime?No
ExamplesChatbot Q&A, text summarizer, translator, code reviewer
If you replace the LLM with hardcoded responses and the program still works the same way — it is NOT an agent.
For Level 1 and 2, swap Claude with a canned string and the program runs identically. For Level 3, the agent breaks because Claude's runtime decisions — which tool, which arguments, when to stop — can't be hardcoded. That fragility is the proof.
3 Things That Must ALL Be True for Level 3
1. Tools
Claude can act on the world — databases, APIs, files.
2. Loop
Claude can act again — the execution path is unknown until runtime.
3. Decisions
Claude chooses based on what it found — not pre-determined by your code.
Chatbot vs Agent in Plain English
Chatbot: Like an airport info desk — you ask "when's the next flight to Chicago?" and they answer from memory. One question, one answer.
Agent: Like a travel assistant who hears your question, pulls up 4 flight options, compares prices, notices your frequent flyer miles, applies them, and books the best option — all from one request.
§5
The 7 Building Blocks of a Production Agent
Think of them like parts of a human body. Drop any one and your agent stops being trustworthy.
Block 1 · Track 1Brain (LLM)
Reads input, reasons about it, decides what to do next, generates text.
Breaks complex tasks into subtasks, decides execution order, retries.
ReAct + max_turns=10
M12–M15
Without it: Only handles simple, one-step requests
Block 5 · Track 5Guardrails (Seatbelts)
Validates inputs & outputs, escalates to humans when unsure.
PII redact, banned_tools list
M16–M18
Without it: Generates harmful content, runs expensive loops
Block 6 · Track 6Eyes (Observability)
Logs every decision, traces tool calls, monitors performance over time.
Langfuse trace IDs
M19–M20
Without it: A black box — when it breaks, you have no idea why
Block 7 · Track 7Home (Deploy)
Runs in production: API design, containerization, scaling, cost control.
Cloud Run + rate limits
M21–M22
Without it: Works on your laptop; nobody else can use it
⚠ Most tutorials only teach you blocks 1 and 2
Brain + Tools = 2 of 7 components. An agent that works on your laptop but can't be trusted in production isn't a product — it's a prototype. This course covers all seven.
§6
The Agent Lifecycle — From Idea to Production
Building an agent isn't just "write code and ship." Five stages, each adding a critical layer.
1
Design
Define scope
What should it do? What tools does it need? What data does it access?
Tracks 1–2
2
Build
Write code
Define tools, engineer prompts, wire up the agent loop. Add RAG if needed.
Tracks 2–4
3
Protect
Add guardrails
Validate inputs/outputs. Cap loops. Add human-in-the-loop for high-stakes actions.
Track 5
4
Observe
Trace everything
Trace every tool call. Log decisions. Score outputs. Without this it's a black box.
Track 6
5
Deploy
Ship a real service
FastAPI / Docker. Cloud Run, Lambda. Cost and rate limits. Real users.
Track 7
⚠ Common Mistake: "I'll add guardrails later"
By the time you discover your agent can hallucinate risk scores or run 200 tool calls per query, you've already deployed it. Build guardrails into your loop from the start — even if they're simple (like a max iteration count).
When NOT to Use an Agent
Situation
Why Not an Agent
Use Instead
Batch processing 1M records
Agent cost: $10K+. Script cost: ~$0
Python script
Sub-100ms response required
Agent latency: 3–15s. Script: milliseconds
Direct API call
Deterministic compliance check
Must be reproducible bit-for-bit. Agents are non-deterministic
Rule engine
Simple CRUD operations
No reasoning needed. Over-engineering
REST endpoint
Logic never changes
Agents add unnecessary complexity to fixed workflows
Hardcoded function
🎯 Decision Rule
If the task requires judgment — weighing ambiguous inputs, synthesizing across sources, or handling edge cases no rule could anticipate — consider an agent. If the logic is deterministic and rule-based, a direct API call is faster and cheaper.
§7
How Agents Actually Work
An agent is your code calling Claude's API in a loop. There's no magic runtime. You are always in control.
// THE UNIVERSAL AGENT PATTERN// Every agent — from calculator to enterprise system — is a variation of this
user_asks_a_question()
while (claude_wants_to_use_a_tool):
// Send the full question + conversation history to Claude
response = send_to_claude(question + history)
if response.stop_reason == "tool_use":
// Claude asked us to run a tool — we run it
result = run_tool(response.tool_name, response.tool_args)
// Send the result back to Claude
history.append(result)
else:
// Claude is done — return the final answer to the userreturn response.text
🔑 What Just Happened?
The while loop is the entire agent. Claude responds with either a tool_use block (run this function) or an end_turn (final answer). If it's a tool request, you run the tool and send the result back — that's one iteration. If it's a final answer, the loop ends. That's it. Really.
How the Tool Call Actually Works
When Claude decides to use a tool, it sends back a structured JSON message like this:
Between API calls, nothing is happening. The agent doesn't "think" while waiting. Every call is stateless — you send the full conversation history each time.
§8
Common Misconceptions — Cleared Up
Students often hear "agent" and assume things that aren't true. Know these cold.
Agents are autonomous AI that run on their own, making decisions 24/7
An agent runs when YOUR code calls it and stops when the task is done. It doesn't think or act between calls. It's a program with an LLM inside a loop — not a self-directed entity.
An agent is basically a smarter chatbot
A chatbot responds from memory in one turn. An agent uses tools, makes decisions, and loops multiple times. The difference isn't intelligence — it's the ability to act on the world and iterate until done.
Agents are complex — hundreds of lines of code
The core agent pattern is about 10–15 lines: a while loop that calls an LLM, checks if it wants to use a tool, runs the tool, and repeats. You'll have a working agent by Module 5.
If I build an agent, it might go rogue and do unintended things
The agent can only use tools YOU define. You control the loop, iteration limits, input validation, output checking, and approval gates. Track 5 (M16–M18) dedicates three modules to agent safety.
I can add guardrails later, after the agent works
Prototypes become products faster than you expect. Retrofitting guardrails costs 4× more than building them during initial development. Build safety in from the start — even a simple max_turns=10 counts.
Claude's built-in safety is enough
Claude has excellent built-in safety, but it cannot know your business rules, compliance requirements, or your users' specific vulnerabilities. Your guardrails complement Claude's — they don't replace each other.
§9
Market Stats Worth Memorizing
When a peer asks "is agentic AI real or hype?" — these are the numbers to keep in your back pocket.
$500M+
raised by agentic-AI startups in early 2024
Capital flowing into workflow automation, agent safety, enterprise integration
20–30%
operational cost reduction reported by enterprises deploying agentic AI
This is the budget line that gets agent projects funded internally
35%
faster decision automation with agentic workflows
Latency to a decision — the metric ops teams actually optimize for
major AI agents launched or majorly updated in 2024–2025 (MIT AI Agent Index)
Space is consolidating around a known list of production agents
>All
papers mentioning "AI agent" in 2024 exceed all prior years combined
Research output is the leading indicator that industry adoption will follow
§10
Quick-Reference Flash Cards
Review these before Module 1. If you can answer all 12, you're ready.
Q: What is a true AI agent? (technical definition)
A program that combines (1) an LLM as its reasoning engine, (2) tools it can call to interact with the outside world, and (3) a loop that keeps it thinking and acting until the task is done.
Q: What's the single question that separates agents from workflows?
"Who decides what happens next — your code, or Claude?" If Claude decides at runtime which tool to call and when to stop, it's a Level 3 agent.
Q: Name the 7 building blocks of a production agent
Brain (LLM) · Tools · Memory · Plan · Guardrails · Eyes (Observability) · Home (Deployment). Covered in Tracks 1–7 of this course.
Q: What is the "universal agent pattern" in pseudocode?
A while loop: send question + history to Claude → if Claude returns tool_use, run the tool and loop back → if Claude returns end_turn, return the answer to the user.
Q: Why are agents possible NOW that weren't in 2022?
Five things converged: tool-use APIs, guaranteed structured output, 200K+ context windows, 1–3 second inference, and a 240× cost reduction per token.
Q: In the Prelude, how is the ML model used differently in Approach 3 vs Approach 1?
In Approach 1, the model IS the product — it takes 6 numbers and returns a probability. In Approach 3, the model is ONE TOOL the agent calls when it needs a probability, after reasoning and searching.
Q: What's the litmus test for a true agent?
Replace the LLM with hardcoded responses. If the program still works — NOT an agent. If it breaks because Claude was making runtime decisions — it IS an agent.
Q: Name 3 situations where you should NOT use an agent
① Batch processing millions of records (cost) ② Sub-100ms response required (latency) ③ Deterministic compliance checks (reproducibility). Use scripts or direct API calls instead.
Q: What does MCP stand for, who made it, and what does it do?
Model Context Protocol. Made by Anthropic (Nov 2024). Standardizes how an LLM connects to tools, resources, and prompts — the "USB-C for AI." Agent ↔ Tool (vertical layer).
Q: What is A2A and how does it differ from MCP?
Agent2Agent Protocol. Google-led, now under Linux Foundation (2025). Standardizes how agents communicate with other agents across orgs (horizontal layer). MCP = agent↔tool. A2A = agent↔agent. Real systems use both.
Q: Deliver the 60-second "whole arc" talking point from memory
"Generative AI evolved in waves. Transformers (2017) enabled understanding. GPT-3 (2020) enabled generating. ChatGPT (2022) brought it mainstream. But LLMs alone are chatbots — they respond, they don't ACT. Agentic AI (2024) adds tool-use, a loop, and memory. The enablers: function-calling APIs, structured output, 200K context, fast inference, 240× cost drop. I build agents combining ML models, RAG, tools, guardrails, and observability. That's the full stack."
MAP
Course Track Map
7 tracks, 30 modules. Building block by building block.
"In five years most APIs will still be FastAPI. Most ML models will still be pickle or ONNX files. The change is Layer 3 — the reasoning that decides how to use the tools and models. That is what this course teaches you to build."