ReAct reasoning, multi-agent architectures, and the patterns that separate demos from production systems
By the end of this session, you'll have both conceptual understanding and hands-on experience with the foundations of AI.
Understand Reason + Act: how production agents think before they act, observe results, and adapt. Build an agent that reasons visibly through a multi-step research task.
Learn three patterns — Pipeline, Debate, and Orchestrator — and when each is the right call. Design a multi-agent system on paper.
Hands-on: take your Session 5 tools (Wikipedia, web fetch, calculator) and add a ReAct system prompt. Same tools, same loop — one paragraph transforms the behavior. Then push it to failure with real APIs.
Apply the Automation Matrix to decide what to automate, what to augment, and what stays human. Calculate agent ROI with a real framework.
A carefully crafted progression from concepts to hands-on building.
Bridge from Session 5's NanoClaw demo — the patterns behind production agents.
The pattern that powers every serious AI agent: Reason + Act. Think, then do, then evaluate, then decide what's next.
Hands-on in Colab. Build an agent that researches, evaluates sources, and synthesizes — with visible reasoning at every step.
Stretch, grab coffee. Your agent now reasons before it acts — that's the production difference.
One agent is useful. A team of agents is powerful. And MCP is how they connect to the world.
Where do agents create real business value? A framework for deciding what to automate, augment, or leave to humans.
Where we've been, where we're going, and why the agentic arc is the future of this course.
Everything you need to explore, experiment, and build.
Projectable lecture companion — visual slides for the full Session 6 lecture with key diagrams, code comparisons, and interactive navigation.
Open lecture guideVisual explainer: ReAct reasoning, Chain-of-Thought planning, multi-agent architectures, and MCP. The patterns that power production AI agents.
View patternsWatch a ReAct agent think step-by-step: search, evaluate sources, extract facts, and synthesize a research report. Interactive trace with real data.
Watch the agentTake your Session 5 tools, change one system prompt, and watch the behavior transform. Three-level comparison, failure exploration with real APIs, and a structured report generator.
Open in ColabOfficial guide to building agentic systems with Claude. Covers tool use, multi-step reasoning, and best practices for production agents.
Read docsThe open standard for connecting AI agents to tools and data sources. Think USB-C for AI. Browse 1,000+ available servers.
Explore MCPAnthropic's guide to building effective agents. Practical patterns, common pitfalls, and when to use agents vs. simpler solutions.
Read guideThe original research paper that introduced the ReAct pattern. Showed that interleaving reasoning and action dramatically improves agent performance.
Read paperAnthropic's agentic coding tool. A real-world example of everything we discussed: ReAct reasoning, tool use, multi-step planning, MCP.
Try Claude CodeThree interactive challenges to build your intuition.
45 minutes in Google Colab. Build an agent that uses ReAct reasoning to research, evaluate, and report:
Bring back your Session 5 tools (real Wikipedia, web fetch, calculator). Run the same research question three ways: no tools, Session 5 agent, ReAct agent. See the difference one system prompt makes.
The agent loop is your Session 5 run_agent() — the only change is the system prompt that tells the agent to THINK before each action. Watch the same tools produce dramatically better research.
Test failure modes with REAL APIs: Wikipedia 404s for made-up companies, vague opinion questions, ambiguous queries. Does the agent recover? Does it admit uncertainty? Does it hallucinate?
Generate a structured research briefing from the agent's work. Then add a 4th tool using a real API (weather, country data, etc.) — see the worked example and build your own.
┌─────────────────────────────────────────────┐
│ LEVEL 0: No Tools │
│ → Generates text from training data │
│ → "AI affects 40% of jobs..." (real? 🤷) │
│ ❌ Looks good. No way to verify. │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ LEVEL 1: Session 5 Agent (same tools!) │
│ → wikipedia_search("AI") │
│ → "Here's what Wikipedia says: [dump]" │
│ ⚠️ Real data, but grabbed first result. │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ LEVEL 2: ReAct Agent (same tools!!!) │
│ THINK: Need employment data + sources │
│ → wikipedia_search("Technological_unemp") │
│ OBSERVE: Good background, need specifics │
│ THINK: Let me find more targeted data │
│ → wikipedia_search("AI_and_employment") │
│ OBSERVE: Better. Let me verify... │
│ → fetch_web_page("https://...") │
│ THINK: Have enough. Let me synthesize. │
│ ✅ Planned. Evaluated. Synthesized. │
└─────────────────────────────────────────────┘ Design a multi-agent system for a real business process. Think like an architect:
Choose one: customer support ticket handling, weekly competitor report, content publishing pipeline, or employee onboarding. Or pick something from your own experience.
Name each agent, define its specialty, list its tools, and describe when it hands off to the next agent. Think org chart — each agent is a department.
Sketch the pipeline: triggers, handoffs, decision points, and human review gates. Where does a human need to approve? Where can agents run autonomously?
Walk them through your design. They ask: Where could this fail? What needs human oversight? What's the ROI? How does information distort across agents?
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ RESEARCHER │───>│ WRITER │───>│ EDITOR │
│ │ │ │ │ │
│ Tools: │ │ Tools: │ │ Tools: │
│ • web_search │ │ • draft_doc │ │ • check_facts│
│ • read_pdf │ │ • format │ │ • check_tone │
│ • summarize │ │ • cite │ │ • score │
│ │ │ │ │ │
│ Output: │ │ Output: │ │ Output: │
│ Research │ │ Draft │ │ Final report │
│ brief │ │ report │ │ + score │
└──────────────┘ └──────────────┘ └──────────────┘
│ │
│ ┌──────────────┐ │
└─────────>│ COORDINATOR │<────────────┘
│ │
│ Decides: │
│ • Good enough?│
│ • Redo step? │
│ • Send to │
│ human? │
└──────────────┘ Apply the Automation Matrix to a real business process and calculate potential ROI:
Choose a repetitive business task from your job, internship, or a company you admire. Something done at least weekly.
Plot it on two axes: Volume (how often?) and Judgment Required (how much human thinking?). Decide: Full automation, augmentation, or human-only?
Estimate: Hours per week × hourly cost × 52 weeks = annual cost. Subtract agent cost (~$50-200/month API). Factor in error reduction. What's the payback period?
What could go wrong? What's the worst-case failure? Where do you need a human-in-the-loop checkpoint? What's the cost of a wrong answer?
ReAct = Think before you act. The best agents don't just execute — they reason about what to do, observe results, and adapt. This pattern separates toy demos from production systems.
Agent teams beat solo agents. Just like human organizations, specialized agents collaborating on complex tasks produce better results than one agent trying to do everything.
MCP is the USB-C of AI. The Model Context Protocol means you build a tool integration once and every agent can use it. This standard is reshaping how agents connect to the world.
Automate the routine, augment the judgment. The Automation Matrix helps you decide what to fully automate, what to augment with AI, and what must stay human.
The code changed one paragraph. The thinking changed everything. Your Session 5 agent — same tools, same loop — became a research powerhouse with one system prompt change. That's the ReAct pattern.
Complete these tasks before our next class to prepare for prompt engineering.
Your agent is smart, but it doesn't know YOUR business. Add company knowledge with Retrieval-Augmented Generation.