Hugging Face Agents Course: A Free Curriculum for Building AI Agents

What the Agents Course teaches and who it is for

The Hugging Face Agents Course is a free, self-paced curriculum for developers who want to build AI agents. Enrollment is through hf.co/learn/agents-course. The README states the prerequisites directly: basic knowledge of Python and basic knowledge of LLMs. There is no introductory path for someone who has never written Python or who does not know what a large language model is.

The course spans four main units plus bonus units, and the README describes its arc as taking learners "from the basics of agents to a final assignment with a benchmark." The final unit includes an automated evaluation of the agent the learner builds and a public leaderboard displaying results across all students.

The course is licensed under Apache-2.0. The primary language of the repository source files is MDX, the format used to author interactive documentation on the Hugging Face hub. The last push to the repository was on 2026-09-15, and the repository has been updated regularly.

Course structure: four units from theory to certification

Unit 0 covers prerequisites, guidelines, the tools needed to follow the course, and an overview. Unit 1 introduces the definition of agents, explains how LLMs relate to agents, covers the model family tree, and discusses special tokens. The first bonus unit goes further into Unit 1's territory: it teaches how to fine-tune an LLM specifically for function-calling.

Unit 2 introduces three agent frameworks as separate sub-units. Unit 2.1 covers smolagents, described as "a lightweight framework for creating capable AI agents." Unit 2.2 covers LlamaIndex, described as a toolkit for building "LLM-powered agents over your data using indexes and workflows." Unit 2.3 covers LangGraph, described as a way to build "production-ready applications" with "control tools over the flow of your agent." The second bonus unit covers observability and evaluation.

Unit 3 covers Agentic RAG, the pattern of combining retrieval-augmented generation with agent behavior to handle different use cases across frameworks. Unit 4 is the final project: the learner creates an agent, tests it against an automated evaluation, and a leaderboard displays results alongside other students. Completing Unit 4 leads to the course certificate.

A third bonus unit, outside the numbered sequence, covers agents in games using the Pokemon setting as its domain.

Three frameworks compared: smolagents, LlamaIndex, and LangGraph

The course covers three frameworks in Unit 2, and the README gives a one-sentence description of each that signals their intended use. smolagents is positioned as lightweight, suitable for creating capable agents without high framework overhead. LlamaIndex is positioned around data: the README describes it as building agents over your data using indexes and workflows, which points to use cases where the agent must retrieve from and reason over a document corpus. LangGraph is positioned for production: the README describes it as giving developers "control tools over the flow of your agent," implying it is suited for complex, stateful workflows where control over execution order matters.

The course does not compare these three frameworks directly in the README. Each has its own sub-unit, and learners who want to understand when to choose smolagents over LangGraph will need to work through both sub-units. The bonus unit on observability and evaluation in Unit 2 covers how to trace and assess agent behavior, which applies to agents built with any of the three frameworks.

Where to start and how to navigate the course

The course has no installation step. It is hosted on the Hugging Face hub at hf.co/learn/agents-course, and the README gives two entry points: enroll at bit.ly/hf-learn-agents to track progress, or open the course directly at hf.co/learn/agents-course. The GitHub repository holds the MDX source files but is not the intended reading surface; the hub renders quizzes, navigation, and formatted content that the raw MDX files do not.

The right starting point is Unit 0 at huggingface.co/learn/agents-course/en/unit0/introduction. That unit covers prerequisites, guidelines, and the tools needed before moving to Unit 1. The README makes the sequencing explicit: Unit 0 is orientation, Unit 1 is where the technical content begins with agent definitions and LLM fundamentals.

The GitHub repository organizes its source files under units/ and quiz/, with scripts/ and translation_agreements/ alongside. A learner who prefers to read the MDX source offline can clone the repository, then navigate to units/ to find the per-unit folders. The README does not provide a pip install command or any other shell setup step, because the course content runs in a browser rather than in a local Python environment. Community discussion is available through the Discord server at discord.gg/UrrTSsSyjb.

What the course does not cover and where it has limits

The course explicitly requires basic Python and basic LLM knowledge. There is no Unit 0 equivalent that teaches Python or introduces transformer models from scratch. A developer who has never trained or called an LLM API needs to acquire those prerequisites elsewhere before the course will be approachable.

The repository has no GitHub releases. There is no versioned snapshot of the curriculum for learners who want a frozen reference or for instructors who want to teach from a specific known state. The course content evolves as commits are pushed to the main branch.

The README does not describe how long each unit takes to complete or how much compute is required for the fine-tuning bonus unit. A learner planning around a specific timeline cannot estimate the workload from the README alone.

Unit 2 covers smolagents, LlamaIndex, and LangGraph, but this breadth means each framework receives sub-unit depth rather than a complete treatment. A developer who needs to master LangGraph specifically will likely need supplementary resources beyond what this course provides. The course is structured as an introduction across frameworks, not as comprehensive documentation for any single one.

License, contributions, and citing the course in publications

The course is licensed under Apache-2.0, which permits use, modification, and redistribution with attribution. This applies to the repository source files; the terms under which the hosted course at hf.co/learn/agents-course can be reproduced or adapted are not described in the README.

Contributors are encouraged but the process differs by scope. Small corrections go directly as pull requests. Adding a new unit requires opening a repository issue first, describing what the unit would cover and making the case for including it.

For researchers who need to cite the course in a publication, the README provides a BibTeX entry naming Ben Burtenshaw, Joffrey Thomas, Thomas Simonini, and Sergio Paniego as authors. It uses the GitHub repository URL as the canonical reference with the year 2025.

Editorial conclusion

The Hugging Face Agents Course suits developers who already know basic Python and have worked with LLMs and want a free, structured path through three major agent frameworks with a certification at the end. It is not for complete beginners to Python or machine learning. Before enrolling, check whether the unit on the specific framework you want to use (smolagents, LlamaIndex, or LangGraph) covers the depth your project requires, since each framework gets its own sub-unit rather than a comprehensive standalone treatment.

Frequently asked questions

Official sources

1. huggingface/agents-course on GitHub
2. Issues
3. License: Apache-2.0
4. README