agents-course

Teaches the foundational TAO (Thought-Action-Observation) cycle through structured lessons that decompose agent decision-making into discrete steps: LLM reasoning (Thought), tool invocation (Action), and result integration (Observation). The course uses a four-unit progression model that builds from basic LLM concepts to complex multi-framework implementations, with each unit scaffolding knowledge through conceptual explanations, code walkthroughs, and interactive quizzes that validate understanding of agent loop mechanics.

Provides side-by-side architectural comparisons of three distinct agent frameworks (smolagents, LlamaIndex, LangGraph) by mapping their core classes, execution models, and use cases to the same underlying agent concepts. Each framework section explains how it implements the TAO cycle differently: smolagents uses code generation, LlamaIndex uses RAG-focused workflows with QueryEngine abstractions, and LangGraph uses explicit StateGraph nodes with conditional routing. The course teaches when to choose each framework based on problem characteristics (general-purpose vs. document-heavy vs. complex state management).

Teaches how to use the GAIA (General AI Assistant) benchmark to evaluate agent reasoning quality across diverse tasks. GAIA provides a standardized set of multi-step reasoning tasks with ground truth answers, enabling consistent comparison of agent implementations, frameworks, and model choices. The course covers benchmark task structure (questions requiring multi-step reasoning, tool use, and information synthesis), evaluation metrics (exact match, partial credit), and how to interpret benchmark results to identify agent weaknesses. Includes patterns for running agents against benchmarks, collecting failure cases, and using benchmark results to guide agent improvements.

Provides a structured learning platform built on Hugging Face's infrastructure with progressive units, quizzes, and community features (Discord integration). The course uses a hierarchical table-of-contents system that guides learners through four units plus bonus content, with each unit containing conceptual lessons, code walkthroughs, and knowledge checks. The platform supports multilingual content (English primary, partial Chinese translations), enabling global accessibility. Community features (Discord channel) enable peer learning and instructor support, creating a cohort-based learning experience.

Teaches smolagents' dual-agent approach where CodeAgent generates executable Python code as its reasoning output (allowing complex logic, loops, and conditionals) while ToolCallingAgent uses structured JSON schemas for tool invocation. The course explains how smolagents integrates with Hugging Face Hub for model access, how to define custom tools with type hints and docstrings, and how the framework handles code execution sandboxing. Includes patterns for error recovery, tool chaining, and leveraging code generation for multi-step reasoning that would require explicit prompting in other frameworks.

Teaches LlamaIndex's agent architecture which couples retrieval-augmented generation (RAG) with agent reasoning through QueryEngine abstractions that encapsulate document indexing, retrieval, and synthesis. The course explains how LlamaIndex agents differ from general-purpose agents by optimizing for document-heavy workflows: agents use QueryEngine to retrieve relevant context before reasoning, reducing hallucination and grounding responses in source documents. Includes patterns for multi-document reasoning, hierarchical indexing, and combining multiple QueryEngines (e.g., vector search + keyword search) within a single agent.

Teaches LangGraph's explicit state management approach where agents are modeled as directed graphs with nodes representing processing steps and edges representing conditional transitions. The course explains how StateGraph maintains typed state across agent steps, enabling complex workflows with branching logic, loops, and human-in-the-loop interventions. Unlike implicit state in other frameworks, LangGraph requires explicit state schema definition and transition rules, making agent flow transparent and debuggable. Includes patterns for error recovery, state persistence, and multi-agent coordination through shared state graphs.

Teaches how to define tool schemas using JSON Schema or Python type hints that enable LLMs to invoke functions reliably. The course covers how different LLM providers (OpenAI, Anthropic, Hugging Face) implement function calling differently (OpenAI uses tool_choice, Anthropic uses tool_use blocks, open-source models require prompt engineering), and how agent frameworks abstract these differences. Includes patterns for schema validation, error handling when LLMs generate invalid function calls, and optimizing schemas to reduce hallucination (e.g., using enums instead of free-text fields).

Teaches techniques for fine-tuning LLMs to improve their ability to invoke functions correctly and reason through multi-step agent tasks. The course covers dataset preparation (collecting agent trajectories with correct function calls), training approaches (supervised fine-tuning on function calling examples), and evaluation metrics (function call accuracy, reasoning quality). Includes patterns for using synthetic data generation to create fine-tuning datasets when real agent logs are unavailable, and how to measure improvements in agent performance post-fine-tuning.

Teaches techniques for monitoring agent behavior, tracing execution paths, and evaluating agent quality against standardized benchmarks. The course covers logging agent steps (thought, action, observation), visualizing agent decision trees, and using benchmarks like GAIA (General AI Assistant) to measure agent reasoning quality. Includes patterns for identifying failure modes (e.g., tool hallucination, reasoning loops), debugging agent behavior through execution traces, and comparing agent performance across frameworks and model choices.

Teaches a specific agent application pattern called 'Agentic RAG' where agents actively decide which documents to retrieve and how to synthesize information across multiple sources, rather than passively using retrieved context. The course uses Alfred (a document-aware agent) as a concrete example, showing how agents can reason about document relevance, ask follow-up questions to refine retrieval, and synthesize contradictory information from multiple sources. Includes patterns for handling document uncertainty, managing context windows when dealing with large retrieved sets, and optimizing retrieval strategies based on agent reasoning.

Teaches agent design through a concrete game-playing application where agents control Pokémon in battles, requiring real-time decision-making, opponent modeling, and strategic reasoning. The course walks through building agents that evaluate game state, predict opponent moves, and select optimal actions (attack, switch, item use) under uncertainty. This application demonstrates agent capabilities beyond text generation: state management (game board), multi-step planning (battle strategy), and competitive reasoning (opponent modeling). Includes patterns for handling imperfect information, managing agent state across multiple turns, and evaluating agent performance through win rates.