Hello-Agents: Datawhale's "Building Agents from Scratch" Systematic Tutorial

Hello-Agents is Datawhale community's "Building Agents from Scratch" tutorial-on GitHub it sits at 69,000 stars, 8,593 forks, Python, CC BY-NC-SA 4.0 license, repo created September 7, 2025, latest release V1.0.3, Trendshift-listed. Note that it is not a runtime framework but a start-to-finish Chinese-language curriculum on building agent systems-five parts, sixteen main chapters, plus a dozen-plus community selections-running from agent definitions and history through hand-coded ReAct/Plan-and-Solve/Reflection, to the self-built HelloAgents framework, Agentic RL training, and capstone projects like a smart travel assistant and a cyber town, with runnable code for everything in the code folder. In one line: take you from an LLM "user" to an agent-system "builder."

What Pain It Solves

2025 is widely called the "Year of the Agent"-the technical focus has shifted from training ever-larger foundation models to building smarter agent applications-yet systematic, practice-heavy tutorials remain extremely scarce. Resources on the market fall mainly into two camps: low-code platform "user manuals" like Dify, Coze, and n8n, which teach drag-and-drop orchestration but not the underlying principles, so switching frameworks leaves you stranded; and scattered official docs for individual frameworks (LangGraph, AutoGen, AgentScope), each covering only its own ecosystem. The English world has agent courses from Andrew Ng and DeepLearning.AI, but a Chinese systematic tutorial that goes all the way from theory to a self-built framework and model training is essentially a blank. Anyone wanting to truly build AI-native agents had to stitch together fragments-symbolic-AI history, Transformer basics, the ReAct paradigm, RAG memory, the MCP protocol, GRPO training-on their own. Hello-Agents turns that path into a free Chinese curriculum, with a core thesis of piercing through framework surfaces, starting from the core principles of agents, and ultimately building your own multi-agent application by hand.

Five Parts, Sixteen Chapters: A Complete Path from Theory to Capstone

The tutorial is organized into five parts and sixteen chapters, every chapter marked complete-a full ladder from foundation to rooftop.

Part I is the theoretical foundation-three chapters clarify "what is an agent, where does it come from, what drives it." Part II is the hands-on starting point: Chapter 4 hand-codes the three classic paradigms-ReAct, Plan-and-Solve, Reflection-line by line, then takes readers across low-code platforms and mainstream frameworks, and finally Chapter 7 builds a framework of your own from zero. Part III makes the agent "learn to think and collaborate," using the Part II self-built framework to dig into memory, context, protocols, training, and evaluation. Part IV is comprehensive practice, consolidating everything into real projects. Part V closes with a capstone design that comprehensively tests what you've learned.

Two Routes in Conflict: AI-Native vs. Flow-Driven

This is the tutorial's core thesis. The README explicitly splits current agent building into two camps: software-engineering agents like Dify, Coze, and n8n, which are essentially flow-driven software development with the LLM as a data-processing backend; and AI-native agents, which are genuinely AI-driven. Hello-Agents targets the latter, taking you past framework surfaces and starting from core principles. So Chapter 4 does not teach you how to call some framework's API-instead it hand-implements the three classic paradigms-ReAct (interleaved reasoning and action), Plan-and-Solve (plan first, then solve), and Reflection (self-critique and correction)-line by line; these are the underlying skeleton of every agent framework, unchanged when the framework changes. Chapter 5 then surveys low-code platforms (Coze/Dify/n8n), and Chapter 6 gets hands-on with mainstream frameworks like AutoGen, AgentScope, and LangGraph, so you've "used the wheels and understand how others build them." By Chapter 7 you build your own agent framework from scratch on the OpenAI native API-by the end you can both "use wheels" and "build wheels," and won't be trapped by any single framework's version upgrades.

Self-Built Framework + Agentic RL: From "Using Wheels" to "Building Wheels" to "Training Models"

The HelloAgents framework built in Chapter 7 (a separate repo at github.com/jjyaoao/helloagents, based on the OpenAI native API) is the foundation for the advanced chapters. Part III uses it to dig into four core skills: Chapter 8 covers memory & retrieval-memory systems, RAG, storage; Chapter 9 covers context engineering, handling "situation understanding" in continuous interaction; Chapter 10 covers agent communication protocols, parsing MCP, A2A, and ANP; Chapter 12 covers performance evaluation-core metrics, benchmarks, and evaluation frameworks. The most distinctive piece is Chapter 11, Agentic-RL-a full pipeline from SFT to GRPO for hands-on LLM training, a territory almost no agent tutorial touches, which Hello-Agents turns into runnable code. The three Part IV capstones also have real landing points: Chapter 13's smart travel assistant implements MCP and multi-agent collaboration, Chapter 14 reproduces an automated deep-research agent (DeepResearch Agent), and Chapter 15 builds a cyber town combining agents with a game to simulate social dynamics. The tutorial also provides all companion code in the code folder and strongly recommends reading and running side by side. Beyond that, the community-contributed Extra-Chapter series has grown to a dozen-plus extensions, covering an Agent interview-question summary with answers, context-engineering supplements, a step-by-step Dify tutorial, GUI Agent and WebAgent hands-on, Agent Self-Evolution, and travel-assistant post-training-a substantial body of incremental content beyond the main text.

Three-Minute Setup

This is a learning tutorial, not a runtime to install-"setup" just means starting to read and run the code.

# 1. Read online (no download needed)
# Global: https://datawhalechina.github.io/hello-agents/
# China mirror: https://hello-agents.datawhale.cc

# 2. Clone locally, read by chapter
git clone https://github.com/datawhalechina/hello-agents.git
cd hello-agents
# Main text is in docs/, follow the chapter directories in order

# 3. Run the companion code
cd code                      # all chapter companion code
# The HelloAgents framework from Ch 7 onward needs an OpenAI API key

# 4. For an offline PDF
# GitHub Releases: https://github.com/datawhalechina/hello-agents/releases/latest/
# China download: https://www.datawhale.cn/learn/summary/239

Prerequisites: basic Python programming, and a conceptual understanding of large language models (knowing how to call an LLM via API is enough)-no algorithm or model-training background required. The project's focus is application and construction.

Who It's For + Five Pitfalls

For: AI developers, software engineers, in-school students, and self-learners with a programming foundation; anyone who wants to evolve from an LLM "user" into an Agent "builder"; job seekers-the Extra-Chapter series includes an Agent-role interview-question summary with reference answers, plus capstone projects that boost a resume; and teaching scenarios, as a Datawhale community tutorial suited for courses or self-study.

Five pitfalls. One, mind the positioning: this is a tutorial, not a production tool-don't expect to clone it and deploy a runtime agent; the HelloAgents framework from Chapter 7 is a teaching build, and for production you'll need to harden it yourself. Two, mind the license: CC BY-NC-SA 4.0 is explicitly non-commercial, read the terms before commercial use, and the PDF carries a pre-embedded Datawhale watermark to deter resale by marketing accounts. Three, chapters are complete but content is still evolving: all 16 main chapters are marked complete, but video courses are still being released, the tutorial repo has reached release V1.0.3, and the self-built HelloAgents framework has been evolving since V1.0.0-follow the main line and pick extensions as needed. Four, the scope is not small: 16 main chapters plus a dozen-plus extensions, running all the companion code is a real commitment, not a weekend crash course. Five, cost: the Part III Agentic-RL and advanced chapters need an OpenAI API budget, and GRPO training has GPU requirements, so pace yourself.

vs. the Competition

Against low-code tutorials for Dify/Coze/n8n, the essence is "use tools" vs. "understand principles": the former is fast and gets a working agent immediately, but leaves you stranded the moment you switch frameworks, with the LLM only processing data on the backend; Hello-Agents pierces through to the core principles of AI-native agents, hand-coding ReAct/Plan-and-Solve/Reflection, building a self-built framework, and going all the way to Agentic RL, so you can "build tools." Against official framework docs (LangGraph, AutoGen, AgentScope), those are scattered API references that each cover only their own ecosystem; Hello-Agents is a single unified Chinese curriculum that compares multiple frameworks and ships its own self-built framework, with a clear progressive path across 16 chapters. Against English agent courses (e.g. the Andrew Ng / DeepLearning.AI series), it matches them on depth and hands-on volume, and is Chinese, free, Trendshift-listed, and Datawhale-community-backed, with companion code and interview questions ready to go. In one line: to get a runnable agent in three days, go to a low-code platform; to systematically understand AI-native agents and build one by hand, pick Hello-Agents.

References

• Hello-Agents GitHub repo (69k stars, Python, CC BY-NC-SA 4.0): https://github.com/datawhalechina/hello-agents
• Online reading (global): https://datawhalechina.github.io/hello-agents/
• Online reading (China mirror): https://hello-agents.datawhale.cc
• PDF download (GitHub Releases, V1.0.3): https://github.com/datawhalechina/hello-agents/releases/latest/
• Self-built HelloAgents framework (OpenAI native API): https://github.com/jjyaoao/helloagents
• Trendshift listing: https://trendshift.io/repositories/15520