Hugging Face Agents Course: An MDX Syllabus for Building and Certifying LLM Agents
This repository contains the Hugging Face Agents Course.
At a glance
- What is it?
- The repository is the source of an open course that runs from agent fundamentals through smolagents, LlamaIndex and LangGraph to a benchmarked final project. It is a teaching curriculum, not a library, and its value depends on whether you want a guided path or a reference.
- Who is it for?
- Adopt this course if you already write Python and want a structured route from agent definitions to a benchmarked final assignment, and if you are willing to work inside Hugging Face's tooling and course platform. Skip it if you need production reference architecture for one specific framework, since the material is teaching content spread across three frameworks rather than a deep implementation guide.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly MDX, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What the Agents Course repository actually contains
This repository is the source material for the Hugging Face Agents Course, a structured curriculum rather than a software library. The README states the course is divided into four units that take a learner from the basics of agents to a final assignment with a benchmark, and it links to a hosted version at hf.co/learn/agents-course. The primary language of the repository is MDX, which tells you what the artifact is: lesson pages, not Python packages. The topics list (agentic-ai, agents, course, huggingface, langchain, llamaindex, smolagents) describes the subject matter covered, not dependencies you install.
The stated prerequisites are basic knowledge of Python and basic knowledge of LLMs. There is no mention of prior experience with agent frameworks, vector stores or evaluation tooling, so the course positions itself as an entry point into agent construction rather than a resource for people already shipping agents. The intended audience is therefore a developer or technically curious reader who can read Python and understands what a language model is, and who wants a guided sequence instead of assembling a reading list from blog posts.
The four-unit structure is the core of the offering. Unit 0 covers welcome material, guidelines and necessary tools. Unit 1 introduces agents, LLMs, a model family tree and special tokens. Unit 2 surveys frameworks. Unit 3 applies agentic RAG to use cases. Unit 4 is the final project, described as create, test and certify your agent, with automated evaluation and a leaderboard of student results. Three bonus units sit alongside this spine: fine-tuning an LLM for function calling, observability and evaluation, and agents in games with Pokemon.
How the curriculum is sequenced from definitions to a leaderboard
The progression is deliberate. Unit 1 establishes vocabulary before any framework appears: definitions of agents, the model family tree and special tokens. That ordering matters because special tokens and function-calling formats are the substrate that the later framework units build on. A reader who jumps straight to Unit 2 without the token-level context will find the framework material harder to place.
Unit 2 is where the course splits three ways. The README describes an overview of smolagents, LangGraph and LlamaIndex, then dedicates a subsection to each: smolagents as a lightweight framework for creating capable AI agents, LlamaIndex for building LLM-powered agents over your data using indexes and workflows, and LangGraph for production-ready applications with control over the flow of your agent. Those three descriptions are the course's own framing, and they signal the intended contrast: a minimal agent loop, a data-and-index orientation, and explicit graph control. Whether the lessons go deep enough on each is something only the unit pages can answer, and the README does not quantify lesson length or exercise count.
Unit 3 moves from frameworks to a use case, agentic RAG, described as helping agents respond to different use cases using various frameworks. Unit 4 closes the loop with automated evaluation of agents and a leaderboard with student results. That final structure is the most distinctive part of the design: the course ends in a submission that is scored, and the bonus unit on observability and evaluation supplies the tracing and evaluation vocabulary needed to interpret those scores. The bonus unit on fine-tuning for function calling and the Pokemon games unit sit outside the main path and appear to be optional depth.
Getting the course running and the contribution path
There is no install command in the README, because the repository is course content rather than a package. The README gives two access routes: a free sign-up link at bit.ly/hf-learn-agents and the course itself at hf.co/learn/agents-course. The unit links in the content table are absolute URLs under huggingface.co/learn/agents-course, for example the Unit 1 introduction at /en/unit1/introduction and the smolagents subsection at /unit2/smolagents/introduction. If you want to read or edit the source, the repository is on the main branch and the files are MDX, so a local clone gives you the lesson text and assets rather than a runnable application.
The contribution guidelines are explicit about two paths. For small typo and grammar fixes, the README says to fix it yourself and submit a pull request, noting this is very helpful for students. For a new unit, the instruction is different: create an issue describing the unit and why it should be added, discuss it, and only then collaborate on it. That asymmetry is sensible for a course with a fixed four-unit spine, since inserting a unit changes the sequence for every learner. There is also a Discord link for discussion, and an issue tracker as the stated first step for larger proposals.
If you cite the material in publications, the README supplies a BibTeX entry with the author list (Burtenshaw, Thomas, Simonini and Paniego), the title The Hugging Face Agents Course, year 2025, and the GitHub URL as howpublished. That is the canonical attribution the maintainers ask for.
Where the course format constrains what you get
The clearest limitation follows from what the repository is. MDX lesson files cannot be executed as a library, so nothing in the README tells you the versions of smolagents, LlamaIndex or LangGraph the lessons target, and no release has been published from this repository. A reader who follows a Unit 2 example months after it was written has no version pin to check against. Framework APIs in this space change quickly, and the README offers no compatibility statement.
The three-framework survey is a second trade-off. Covering smolagents, LlamaIndex and LangGraph in one unit means each gets a subsection rather than a full treatment. If your goal is to become proficient in one of them, the course gives you orientation and a working example, not exhaustive coverage of that framework's edge cases. The README's own descriptions are short enough to fit in a table cell, which is a fair indication of scope.
The certification path is also platform-bound. Unit 4 describes automated evaluation and a leaderboard with student results, and the sign-up link points to a Hugging Face hosted flow. That is fine if you want the credential and the leaderboard comparison, but it means the final assessment is not something you run entirely offline from the repository contents. The README does not describe the evaluation harness, the scoring criteria or how submissions are validated, so anyone treating the final project as a reproducible benchmark should verify those details on the course site first. Finally, the prerequisites assume LLM familiarity; a reader who does not already know what a token or a function call is will need outside material before Unit 1 lands.
How it compares with framework documentation and cookbook repositories
The natural alternative is the official documentation and example galleries of the frameworks the course covers, such as the smolagents, LlamaIndex and LangGraph docs, or a cookbook-style repository of runnable notebooks. The difference in approach is structural. Framework docs are reference material organized by API surface, optimized for lookup once you know what you are building. This course is organized by learning sequence, optimized for someone who does not yet know which framework fits their problem. That is why Unit 1 spends time on model family trees and special tokens before any framework appears, and why Unit 4 ends in an evaluated submission rather than a reference page.
The trade-off is currency and depth. Framework documentation tracks the current release and covers the full API; a course repository with no published releases and MDX lessons may lag behind a breaking change. Conversely, documentation rarely tells you when to prefer a lightweight agent loop over a graph-based flow, which is exactly the comparison Unit 2 sets up by placing smolagents, LlamaIndex and LangGraph side by side. If you already know your framework, the docs win. If you are choosing, the course's guided comparison is the more useful starting point, provided you check the framework versions in the lessons against what you plan to install.
Licence, maintenance and what to verify before starting
The repository is licensed Apache-2.0, which permits reuse and modification under the terms of that licence, including its patent grant and notice requirements. This is a note about the licence identifier, not legal advice; if you plan to repackage the lesson content, read the full licence text and the repository's NOTICE conventions rather than relying on the identifier alone. The citation block asks for attribution in publications, which is a request in the README rather than a licence term.
On maintenance, the repository shows a last push of 2026-09-09 and no retrieved releases. There is no published versioning scheme, so there is no upgrade path in the conventional sense: you re-read the lessons or pull the branch. For a learner, the maintenance cost is time spent re-checking framework examples against current library versions. For a contributor, the cost is the review process described in the guidelines, with an issue first for anything larger than a typo.
Before you invest hours, verify three things on the course site. First, open the Unit 2 framework pages and confirm that smolagents, LlamaIndex and LangGraph match the stack you actually use. Second, check the Unit 4 page for how automated evaluation and the leaderboard work, since the README does not describe the harness. Third, confirm the sign-up flow and whether the hosted course is still the intended entry point, because the README routes learners there rather than through a local build.
Editorial conclusion
Adopt this course if you already write Python and want a structured route from agent definitions to a benchmarked final assignment, and if you are willing to work inside Hugging Face's tooling and course platform. Skip it if you need production reference architecture for one specific framework, since the material is teaching content spread across three frameworks rather than a deep implementation guide. Before committing time, open Unit 2 in your browser and check that the framework split matches your stack, then read the contribution guidelines if you intend to submit fixes rather than consume the syllabus.
Community notes