Learning Hello-Agents: A Systematic Roadmap to Building AI Agents from Scratch

Calling a large language model API once doesn't mean you've built an agent. The real challenge is organizing planning, tools, memory, context, collaboration, and evaluation into a system that can complete tasks. Recently, I added the open-source tutorial from Datawhale Hello-Agents: Building Agents from Scratchto my learning list, planning to complete it with a "read a chapter, run it once, modify one thing, and leave a record" approach.

Project Source and Copyright Notice

Original project:Hello-Agents: Building Agents from Scratch
Initiated and maintained by the Datawhale community and all contributors to Hello-Agents
Online documentation:Domestic access / GitHub Pages
Open-source license:CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike)

This article is a personal study guide compiled from the project's official README and chapter outline. It is not the full official tutorial, nor does it represent the official stance of Datawhale. The rights to the project name, course structure, and related materials belong to the original authors and contributors; the review date is August 4, 2026.

Why choose it as a learning path

The value of Hello-Agents goes beyond introducing a few popular frameworks. It first explains the fundamentals of agents and large language models, then moves into classic paradigms such as ReAct, Plan-and-Solve, and Reflection, followed by low-code platforms, code frameworks, custom frameworks, memory and retrieval, context engineering, communication protocols, Agentic RL, and performance evaluation, and finally wraps up with complete case studies.

This path connects "using models" with "designing systems." Along the way, you'll encounter tools like Dify, Coze, n8n, AutoGen, AgentScope, and LangGraph, but you'll also be encouraged to look beyond the tools and understand more stable capabilities such as planning, acting, feedback, and iteration.

What you need before starting

The official prerequisites are clear: basic Python programming skills, a basic understanding of large language models, and ideally knowing how to call an LLM via API. It does not require deep algorithm or model training backgrounds; the focus is on application and building.

• Ability to read and modify Python code, and familiarity with functions, classes, virtual environments, and package management.
• Understand the basic uses of prompts, context windows, model inputs/outputs, and API keys.
• Be willing to run, debug, and modify examples hands-on, not just read conclusions.

Store API keys in local environment variables or config files excluded from version control—never in code, screenshots, or commit history.

Five-Stage Learning Roadmap

1. Build a shared vocabulary (Chapters 1–3):Learn agent definitions, history, and LLM fundamentals. Produce a concept table that explains the relationships among agents, LLMs, tool calling, and multi-agent systems.
2. From usage to building (Chapters 4–7):Learn classic paradigms, low-code platforms, mainstream frameworks, and custom frameworks. Produce a runnable single agent and be able to explain its decision loop.
3. Round out system capabilities (Chapters 8–12):Learn memory, RAG, context engineering, MCP/A2A/ANP, Agentic RL, and evaluation. Add a memory or evaluation module to your agent and leave reproducible comparison results.
4. Complete integrated case studies (Chapters 13–15):Learn the travel assistant, automated deep research, and CyberTown. Fully reproduce one case, then modify it by swapping data, tools, or tasks.
5. Complete the capstone project (Chapter 16):Build your own multi-agent application, delivering goals, architecture, run instructions, evaluation results, and limitations.

My six-week execution plan

Week 1: Foundations.Finish Chapters 1–3, and organize concepts like agents, environments, perception, action, planning, and feedback in your own words. The goal is not to memorize terms but to be able to draw a complete flow from input to outcome for a task.

Week 2: Paradigms.Focus on Chapters 4–5. First implement a minimal ReAct loop, then redo the same task with a low-code platform, comparing where each implementation is more transparent and flexible.

Week 3: Frameworks.Complete Chapters 6–7. Choose a mainstream framework to reproduce examples, while reading the core structure of the self-built HelloAgents framework. Modify at least one tool or piece of decision logic to confirm you truly understand the execution chain.

Week 4: Memory and collaboration.Study Chapters 8–10. Add short-term memory, retrieval, or protocol capabilities to your earlier agent, and record context length, response quality, latency, and failure modes.

Week 5: Training and evaluation.Study chapters 11–12. If compute resources are limited, focus on understanding SFT, GRPO, and evaluation methods, prioritizing building test sets, metrics, and regression logs over blindly pursuing training scale.

Week 6: Case studies and capstone project.Reproduce one case from Travel Assistant, Deep Research, or Cyber Town, then replace the scenario with a problem you genuinely care about to complete the capstone project in Chapter 16.

Start today

If you only want to read, you can directly open theonline documentation (China). To run examples or contribute, clone the official repository:

git clone https://github.com/datawhalechina/hello-agents.git
cd hello-agents

Start by reading docs/preface.md, then follow the README's chapter navigation into the main content. For each chapter, rely on the environment and dependencies specified in that chapter's instructions and the actual files in the code directory—do not install all dependencies into a single Python environment without checking.

For each learning session, I will record five items: this session's goal, key principles, commands run, inputs and outputs, and failure reasons with next experiment. Each week, I require only one verifiable deliverable to avoid mistaking "finished reading" for "mastered."

Resources

• Official GitHub Repository: Code, content, contribution history, and latest changes.
• online documentation (China) / GitHub Pages: Read online without downloading.
• Latest Release: View published releases and PDFs.
• Issues: Search issues, report bugs, or join discussions.

Attribution:The projects and chapters referenced in this article are sourced from the Datawhale community's Hello-Agents official repository, and the original authors recommend citing it as Hello-Agents: Building an AI Agent from Scratch(Sizhou Chen, Tao Sun, Shufan Jiang, et al., 2025). The original project uses CC BY-NC-SA 4.0 License: Please retain attribution and comply with the non-commercial and share-alike terms.