Hands-on Tutorials
Complete facilitator guides with scripts, questions, activities, and implementation materials.
Teaching Philosophy
My teaching integrates cutting-edge research with evidence-based pedagogy. Rather than delivering information, I create environments where students construct understanding through guided exploration, collaborative problem-solving, and intentional struggle.
Learning by Doing
Hands-on coding and experimentation
Socratic Approach
Questions before answers
Research-Informed
Connected to real research
From Prompt to Autonomous System
Overview
An interactive session where students progress through all six levels of Bloom's Taxonomy—from recalling basic AI concepts to creating a fully functional autonomous agent with debugging and ethical reasoning.
Detailed Explanation
This demo addresses a critical gap in AI education: understanding the difference between using AI tools and building AI systems. Students often use ChatGPT daily but don't understand how to create custom AI agents with transparent reasoning, controlled tool access, and domain-specific capabilities. This session bridges that gap through hands-on construction of a working agent using the ReAct (Reasoning + Acting) pattern. Students learn why custom agents matter (control, transparency, extensibility), how agents make decisions (the ReAct loop), how to debug agent failures (analyzing reasoning traces), and how to evaluate safety and ethical considerations. The pedagogical approach scaffolds learning through Bloom's Taxonomy—from basic recall to creative design—ensuring deep, transferable understanding. By the end, students can independently architect agent systems for real-world problems, critique existing implementations, and understand the trade-offs between proprietary AI tools and custom solutions.
Concepts & Definitions
What is an AI Agent?
An AI agent is an autonomous system that perceives its environment, reasons about goals, and takes actions using external tools to achieve objectives. Unlike chatbots that respond to prompts, agents operate in iterative loops—making decisions, executing tools, and adapting based on outcomes.
Key Characteristics:
•Autonomy: Makes decisions without constant human guidance
•Tool Use: Calls external functions (APIs, databases, calculators)
•Iterative Reasoning: Uses ReAct loop (Reasoning + Acting)
•Memory: Maintains context across multiple interactions
•Goal-Directed: Works toward solving complex, multi-step problems
Agent vs Chatbot: Key Distinctions
| Aspect | Chatbot | Agent |
|---|---|---|
| Behavior | Responds to single prompts | Executes multi-step plans autonomously |
| Tools | May use hidden, proprietary tools | Uses custom, transparent, auditable tools |
| Reasoning | Reasoning is opaque | Explicit Thought → Action → Observation traces |
| Control | User controls input, not process | Developer controls tools, data flow, safety |
| Use Case | General Q&A, content generation | Domain-specific workflows, production systems |
Types of AI Agents
ReAct Agents (Reasoning + Acting)
Use iterative reasoning to decide which tool to call at each step. Most common for research, customer service, data analysis.
Examples: Research assistants, Customer support bots, Data analysis agents
Plan-Execute Agents
First create a complete plan, then execute all steps. Better for well-defined, structured tasks.
Examples: Travel booking, Report generation, Workflow automation
Conversational Agents
Maintain long-term memory and context across sessions. Designed for ongoing relationships.
Examples: Personal assistants, Tutoring systems, Health coaches
Multi-Agent Systems
Multiple specialized agents collaborate, each with domain expertise.
Examples: Software development teams, Research collectives, Simulation environments
Core Components of an Agent
LLM (Large Language Model)
The 'brain'—generates reasoning and decides which tools to use
GPT-4, Claude, Llama
Tools
External functions the agent can call (APIs, databases, calculators)
search_wikipedia(), calculate(), send_email()
Memory
Stores conversation history and intermediate results
ConversationBufferMemory, VectorStore
Agent Executor
Orchestrates the ReAct loop—runs reasoning, calls tools, processes observations
LangChain's AgentExecutor
Prompt Template
Defines agent behavior, safety rules, and output format
System prompt with instructions and constraints
Real-World Agent Applications
Clinical decision support agent
Tools:
query_patient_records()
search_medical_literature()
calculate_risk_score()
Outcome: Helps doctors by retrieving patient history, finding relevant research, and computing diagnostic scores
Investment research agent
Tools:
get_stock_data()
analyze_financials()
search_news()
calculate_metrics()
Outcome: Automates fundamental analysis by gathering data, computing ratios, and summarizing market trends
Personalized tutoring agent
Tools:
assess_knowledge()
generate_practice_problems()
track_progress()
adapt_difficulty()
Outcome: Creates adaptive learning paths based on student performance and knowledge gaps
Customer service agent
Tools:
query_order_status()
search_knowledge_base()
issue_refund()
escalate_to_human()
Outcome: Resolves customer issues autonomously while maintaining audit trails and escalation paths
Learning Objectives (Bloom's Taxonomy)
Knowledge
Define core agentic AI terminology: agent, tool, ReAct loop, observation, action, and reasoning. Distinguish between chatbots and autonomous agents.
Comprehension
Explain how the ReAct pattern enables autonomous behavior through the cycle of Thought → Action → Observation. Describe why tool descriptions are critical for agent decision-making.
Application
Implement a functional multi-tool agent using LangChain following the 5-step template: imports, tools, LLM initialization, agent creation, and query execution.
Analysis
Debug agent failures by analyzing verbose execution traces. Identify root causes of tool selection errors, infinite loops, and non-convergence issues.
Evaluation
Critique agent designs for production readiness. Assess risks including hallucination, tool misuse, cost, privacy, and safety. Justify when agents are appropriate versus overkill.
Creation
Design novel agent architectures for domain-specific problems. Select appropriate tools, define safety guardrails, and justify design choices with technical reasoning.
30 minutes
Undergrad to Grad
Bloom's Taxonomy Progression
1. Remember
Recall: What is an LLM? What is a tool? Define 'agent' vs 'chatbot'.
2. Understand
Explain: Why do agents need memory? How does ReAct pattern work? Describe the flow.
3. Apply
Use: Follow along live coding to build a research assistant—apply LangChain patterns.
4. Analyze
Debug: When the agent fails, analyze WHY. Compare expected vs actual behavior.
5. Evaluate
Critique: Is this agent safe? What are risks? Justify design choices for production.
6. Create
Design: Sketch your own agent for a real problem. Define tools, prompts, and guardrails.
Demo Structure with Facilitator Guides
Hook: The Big Question (3 min)Remember
ChatGPT vs Custom Agents: Both can fetch real-time data. So what's the big deal about agents? Live demo comparison reveals the critical differences.
Conceptual Foundation: The ReAct Loop (7 min)Understand
Deep dive into ReAct pattern with visual diagrams, hands-on trace walkthroughs, and real-world tool examples. Students build intuition for how reasoning and action interleave.
Live Coding: Build Together (10 min)Apply
Students follow the 5-step agent template to build a research assistant. Learn the universal pattern for any LangChain agent: imports → tools → LLM → agent → run.
Debugging Challenge (5 min)Analyze
Intentional bug introduced. Students analyze execution trace, compare expected vs actual, identify root cause through interactive debugging game.
Safety & Ethics Discussion (4 min)Evaluate
Evaluate agent risks: hallucination, tool misuse, privacy. Justify when agents should/shouldn't be used. Critique current implementation.
Design Your Own (3 min)Create
Design an agent for your domain using a multiplayer design game. What tools? What safeguards? Share and vote on designs. Synthesis of all concepts.
Learning Outcomes
- Recall core agentic AI terminology and architecture patterns
- Explain how ReAct loops and tool use enable autonomy
- Build a functional agent using modern frameworks
- Analyze and debug agent failures systematically
- Evaluate ethical implications and design trade-offs
- Create novel agent designs for real-world problems
References & Resources
📚 Foundational Papers
- ReAct: Synergizing Reasoning and Acting in Language Models — Yao et al. (2023)[Link]
The original paper introducing the ReAct pattern—essential reading for understanding how agents interleave reasoning and action.
- Toolformer: Language Models Can Teach Them to Use Tools — Schick et al. (2023)[Link]
Demonstrates how LLMs can learn to use external tools through self-supervised learning.
- Chain-of-Thought Prompting Elicits Reasoning in Large Language Models — Wei et al. (2022)[Link]
Foundational work on explicit reasoning traces that influenced ReAct design.
🛠️ Technical Documentation
- IBM: What are AI Agents?[Link]
Comprehensive industry overview of AI agents—covers concepts, architectures, and enterprise applications
- Microsoft Azure AI Foundry: Agents Overview[Link]
Microsoft's guide to building production-ready agents in Azure—practical implementation details and best practices
- LangChain Agents Documentation[Link]
Official LangChain documentation for building agents—includes code examples, patterns, and best practices
- LangChain Tools Documentation[Link]
Comprehensive guide on creating custom tools, handling errors, and debugging tool calls
- OpenAI Function Calling Guide[Link]
Understanding function calling in OpenAI models—the mechanism underlying tool use
📖 Pedagogical References
- Bloom's Taxonomy Revised — Anderson & Krathwohl (2001)
Framework for structuring learning objectives from Remember through Create—used to design this demo's progression.
- How Learning Works: Seven Research-Based Principles — Ambrose et al. (2010)
Evidence-based teaching strategies including scaffolding, active learning, and formative feedback—applied throughout this demo.
- Teaching with Intentional Errors — Siegler (2002)
Research on learning through debugging and error analysis—basis for the debugging challenge section.
🎥 Video Resources
⚠️ Safety & Ethics Resources
- Anthropic Core Views on AI Safety — Anthropic[Link]
Framework for understanding when, why, what, and how AI safety techniques should be applied to prevent catastrophic risks
- Petri: Open-Source AI Auditing Tool — Anthropic[Link]
Open-source tool for exploring and testing AI agent safety through parallel hypothesis testing
- Red Teaming Language Models — Perez et al. (2022)[Link]
Methods for testing agent systems for harmful outputs and unintended behaviors