# Hello-Agents: a from-scratch agent construction course, not a framework

> Datawhale's Hello-Agents is a Chinese-language tutorial that walks from agent theory to a self-built framework and a multi-agent graduation project. It teaches AI-native agents rather than low-code workflow builders, and the repository is a book with code, not a library you pip install.

**datawhalechina/hello-agents** — 📚 《从零开始构建智能体》——从零开始的智能体原理与实践教程

- Repository: https://github.com/datawhalechina/hello-agents
- Website: https://hello-agents.datawhale.cc
- Stars: 81,145 · Forks: 10,088
- Language: Python
- License: NOASSERTION
- Published: 2026-08-24 · Updated: 2026-08-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/datawhalechina-hello-agents

## What Hello-Agents actually is, and who it is written for

The README frames the project around a split in how agents get built. One camp is software-engineering agents in the style of Dify, Coze and n8n, where the LLM sits at the back as a data-processing step inside a flow someone drew by hand. The other camp is what the README calls AI-native agents, where the model drives the control loop. Hello-Agents declares itself a guide to the second camp, and says it wants to take a reader from being a user of large language models to being a builder of agent systems.

That positioning sets the audience. This is not a library you import into a service and ship. The repository layout confirms it: docs/, code/, Extra-Chapter/, Co-creation-projects/ and a fix_bold_format.py script at the top level. It is a book with runnable examples. The people who get value are engineers and students who want the mechanism behind ReAct or Reflection rather than a wrapper call, and who are willing to read Chinese, since the primary text is Chinese with an English README file alongside it.

## The mechanism: sixteen chapters from paradigm to graduation project

The content navigation table is the clearest description of the architecture. It runs in five parts. Part one covers agent definitions, the history from symbolic systems to LLM-driven agents, and the Transformer and prompting basics. Part two is the hands-on core: implementing ReAct, Plan-and-Solve and Reflection directly, then surveying Coze, Dify and n8n, then applying AutoGen, AgentScope and LangGraph, then building a framework from zero in chapter 7. Part three extends into memory and retrieval, context engineering, the MCP, A2A and ANP communication protocols, Agentic RL from SFT to GRPO, and evaluation. Part four is three composite projects: a travel assistant, a DeepResearch agent reproduction, and a simulated town. Part five is a graduation design chapter where the reader builds a complete multi-agent application.

The ordering matters. Frameworks appear in chapter 6, after the reader has already written ReAct and Reflection by hand in chapter 4. That is a deliberate teaching sequence: you see what LangGraph or AutoGen is abstracting before you use it. The framework the course builds itself lives in a separate repository, jjyaoao/helloagents, and the README describes it as built on the OpenAI native API. The tutorial repository is where the explanation lives, not the framework.

## How to start reading Hello-Agents, online or locally

The README gives two online entry points and no package install, because there is nothing to install. The international site is datawhalechina.github.io/hello-agents and the accelerated domestic mirror is hello-agents.datawhale.cc. Both are described as requiring no download.

If you want the files locally, for reading offline or contributing, the README points to a learning guide rather than a command. The practical route is to clone the repository, since the chapters are Markdown files under docs/ and the examples sit under code/. The chapter paths use URL-encoded Chinese filenames, so a clone is more reliable than trying to fetch individual files by hand.

```bash
git clone https://github.com/datawhalechina/hello-agents.git
cd hello-agents
ls docs
```

The listing shows chapter1 through chapter16 plus a preface file, which is the same order as the navigation table. A first real use is to open chapter 4 and work through the ReAct implementation, since that is the first point where the course stops explaining and starts building. Environment setup is not covered in the main README; the community section links Extra-Chapter/Extra07-环境配置.md for that, and it is worth reading before you run any code under code/.

## Where Hello-Agents stops being the right tool

The README is explicit that the course targets AI-native agents and treats low-code platforms as the other camp, covered in chapter 5 mainly so the reader understands them. If your actual job is shipping a workflow in Dify or Coze this week, the course spends its weight elsewhere. Chapter 5 is one chapter among sixteen.

The more consequential limitation is that this is a tutorial, not a maintained runtime. There is no installable package documented in the README, no versioned API surface, and no compatibility promise. The framework code lives in a different repository, so a reader who wants to build on HelloAgents rather than learn from it has to leave this repository to find it. Release tags exist here (V1.0.3 on 2026-07-17, V1.0.2 on 2026-02-10, V1.0.0 on 2025-11-03), and the last push was on 2026-07-17, but those tags version the text. Treating them as library versions would be a mistake.

The licence is another gap. The repository carries a LICENSE.txt file, but the project metadata reports the licence as NOASSERTION, meaning no standard identifier was detected. The README does not discuss reuse terms for the text or the code samples. If you plan to lift code from the chapters into a commercial product, that ambiguity is something to resolve with the maintainers rather than assume away.

## Hello-Agents against LangGraph and AutoGen

The difference is not features, it is what the artifact is for. LangGraph and AutoGen are libraries: you install them, you write against their APIs, and your application depends on them. Hello-Agents is a curriculum that teaches you to write the loop those libraries hide, and chapter 7 has you build your own framework rather than adopt one.

That has a concrete consequence for how you spend time. With LangGraph you get a graph abstraction and a state model you did not design, and you can be productive in an afternoon. With Hello-Agents you write the ReAct loop yourself in chapter 4, and the payoff is that when a library's behaviour surprises you later you can reason about why. The course is also narrower in scope than either library: it is a sequence of chapters with a defined end, not a set of primitives you compose indefinitely. If you need to ship, the libraries win on speed. If you need to understand, the course is doing something the libraries' own documentation does not attempt, because library docs assume you already know the paradigm.

## Maintenance, upgrade cost and the licence question

The repository is not archived, and the last push was on 2026-07-17, roughly two months before this writing. Three release tags exist across 2025-11-03, 2026-02-10 and 2026-07-17, which suggests the text is revised rather than frozen. The chapter table marks every chapter as complete, so the upgrade cost from V1.0.2 to V1.0.3 is reading diffs in Markdown and re-running examples that changed, not migrating an API.

That is the good news. The cost that does not go away is model drift. The course builds on the OpenAI native API and on model behaviour as it stood when a chapter was written. Prompting patterns and agent loops age more slowly than model endpoints, but examples that reference specific models will need substitution as those models are retired. The README does not document a changelog of which chapters were touched in which release, so tracking what changed between V1.0.2 and V1.0.3 means reading the commits yourself.

On licence, the safest statement is the narrow one: a LICENSE.txt is present at the top level, the metadata does not resolve it to a standard identifier, and the README is silent on reuse. Check that file directly before redistributing the text or the code samples.

## Conclusion

Adopt Hello-Agents if you want to understand how AI-native agents are assembled rather than drag blocks in a low-code platform, and if you read Chinese well enough to follow chapter text. Skip it if you need a production runtime with a versioned API, or if you expect a pip-installable library: the README points to a separate HelloAgents repository for the framework code. Before committing time, open chapter 4 and chapter 7 on the online site and check whether the code style and the model API assumptions match your stack, then read Extra-Chapter/Extra07-环境配置.md for the environment setup the main README does not spell out.

## FAQ

### What are the top 3 AI agents, and does Hello-Agents rank them?

The course does not publish a ranking of agents. Its chapter table is organized by topic instead: classic paradigms in chapter 4, low-code platforms in chapter 5, and mainstream frameworks such as AutoGen, AgentScope and LangGraph in chapter 6.

### How exactly do AI agents work, according to Hello-Agents?

The course covers agent definitions, types and paradigms in chapter 1, the history in chapter 2, and then has the reader implement ReAct, Plan-and-Solve and Reflection by hand in chapter 4. It distinguishes AI-native agents, where the model drives the loop, from low-code platforms where the LLM is a backend step in a drawn flow.

### Can you give me an example of a goal-based agent in real life, and does Hello-Agents provide one?

The course does not use the term goal-based agent in its chapter table. Its composite examples in part four are a travel assistant, a DeepResearch agent reproduction and a simulated town, and chapter 15 covers agents combined with a game to simulate social dynamics.

### Is ChatGPT a chatbot or an AI agent, and does Hello-Agents answer that?

The course does not address ChatGPT by name, so it does not answer this directly. It does draw the relevant line in general terms, separating software-engineering agents where the LLM is a data-processing backend from AI-native agents where the model drives the system, and chapter 1 covers agent definitions and types.

## Sources

- [Official documentation](https://hello-agents.datawhale.cc)
- [Official README](https://github.com/datawhalechina/hello-agents#readme)
- [Project repository](https://github.com/datawhalechina/hello-agents)
- [Release notes](https://github.com/datawhalechina/hello-agents/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/datawhalechina-hello-agents