Welcome and Course Overview

Technical Context

Artificial intelligence agents represent a shifting design pattern in software engineering. While early integrations of large language models (LLMs) focused on simple, stateless prompt-response interfaces, production systems increasingly require autonomous execution to achieve complex goals.

From a software engineering perspective, an agent is not an independent entity, but a traditional software application that uses a language model as a dynamic routing and decision-making component. Building reliable agents does not require complex frameworks. Instead, it requires standard engineering rigor: state management, input validation, structured database queries, and error handling.

This course builds an agentic system from first principles, using standard Python control flows without the abstractions of external frameworks. This approach ensures that developers understand the exact mechanics of execution loops, tool calls, and state management.

Curriculum Structure and Roadmap

The curriculum is divided into four modules, progressing from core execution loops to production testing, security, and multi-agent coordination.

• Module 1 - Foundations: Workflows and Agentic Loops: Understanding the transition from static code workflows to dynamic model execution loops. Building a bare-metal execution loop from scratch.
• Module 2 - Core Mechanics: Tools, Memory, and Reflection: Designing tool-calling schemas, interfacing with relational databases (SQL) and text retrieval (RAG) systems, enforcing safety limits on side-effecting operations, and establishing self-correction loops.
• Module 3 - Engineering Rigor: Evaluation and Optimization: Setting up automated assertion-based testing suites (evals), measuring latency and token consumption, and securing systems against adversarial prompt injections.
• Module 4 - Frameworks, Orchestration & Capstone Build: Implementing multi-agent coordination graphs, understanding human-in-the-loop validation patterns, and completing a production-ready customer support agent.

The Target Capstone Project

Throughout the course, lessons build toward a central project: a Customer Support Agent for a commercial retail system.

To perform effectively, the support agent must query a live database to verify transaction histories, search policy documents to evaluate refund eligibility, execute refunds within strict limits, and gracefully route unresolved or high-value claims to human support.

Playground Runtime Architecture

Every interactive lesson in this course runs live code in your browser. The runtime environment utilizes two main architectural components:

• Pyodide Sandbox: A Python runtime compiled to WebAssembly (Wasm) that executes standard Python directly inside your browser. This includes support for in-memory SQLite databases to run local relational queries.
• Completions API Proxy: To facilitate live model interactions, LLM client calls are routed from Pyodide to a Next.js backend proxy endpoint (/api/agentic/model). This proxy attaches secure access keys and relays requests to the model provider, preventing credential exposure.

Comparison: Chatbots vs. Autonomous Agents

To illustrate the difference between a text-generative chatbot and an agent, execute the comparison script below.

• The Chatbot: Relies on its internal parametric memory. When asked about a specific customer order ID, it fails or produces a generic message because it cannot access external databases.
• The Agent: Receives a tool schema signature defining get_shipping_date. When queried with the same order ID, the model analyzes the request, realizes it lacks shipping details, executes the registered function, and passes the result back to generate the final response.

The chatbot cannot retrieve the order status and returns generic customer service advice. The agent identifies the order ID, requests a tool call to retrieve the shipping date, executes the function, and uses the resulting shipment data to formulate a precise answer.

The next lesson analyzes the Fixedness Spectrum, establishing the criteria for selecting the appropriate pattern between deterministic workflows and autonomous agents.