Hello-Agents: Building AI Agents from Scratch

In the past few years, as LLM applications have rapidly matured, many people are no longer satisfied with just being able to "use ChatGPT" or "write prompts." A much more valuable direction is understanding how large language models invoke tools, maintain memory, plan tasks, and collaborate with external systems to become AI Agents that can execute tasks continuously.

Datawhale Community's open-source Hello-Agents is a systematic tutorial centered on AI Agent principles and practice. It is not a simplistic walkthrough of a low-code platform, nor does it simply teach you to plug into ready-made frameworks. Instead, it attempts to guide learners from foundational agent concepts and classic paradigms to engineering implementations and multi-agent applications, making it suitable for people who want a structured introduction to agent development.

1. What This Project Is About

The Chinese title of Hello-Agents is "Build an Agent from Scratch." The project is clearly positioned: from core theory to practical application, it helps learners systematically master the design and implementation of agent systems.

In the project README, the author roughly divides current agent building into two categories: one is Dify, Coze, n8n-style agents focused on software engineering and workflow orchestration, and the other is more AI-native agents—systems where the model genuinely participates in planning, reasoning, tool calling, and task execution.

Hello-Agents focuses more on the latter. It aims to push learners beyond "dragging a few nodes and assembling a flow," and instead progressively understand what really happens inside an agent: how the model receives context, how it decides its next action, how it calls tools, how it handles memory, how it reflects and corrects itself, and how it collaborates on complex tasks.

For me, the value of this tutorial is that it helps people move from "using AI tools" to "understanding the architecture of AI applications." This shift is essential. What creates real personal productivity is not only knowing what a tool is called, but understanding how it works under the hood and being able to apply that in your own projects.

2. Who Is It Suitable For

Hello-Agents is best suited to the following readers:

• People who want to understand AI Agents systematically rather than reading isolated blog posts.
• People already using ChatGPT, Claude, Gemini, etc., who want deeper understanding of the underlying mechanisms.
• People with some Python or programming foundation who want to build agent projects.
• People who want to learn concepts like ReAct, RAG, Memory, context engineering, and multi-agent collaboration.
• People wanting to apply AI Agent capabilities to personal websites, automation tools, knowledge bases, data analysis, or research workflows.

If you only want to quickly build a simple chatbot, a low-code platform may be faster; but if your goal is to understand the underlying logic of agent systems, a "from principles to code" path like Hello-Agents is more worthwhile.

3. Project Structure

From the public README, Hello-Agents appears to cover a fairly complete scope and can be roughly divided into several stages.

1. Basics of Agents and Large Language Models

The tutorial starts with agent concepts, including definitions, types, history, and application scenarios of agents. It then moves to LLM basics, introducing Transformers, prompts, mainstream LLMs, and current limitations of modern large models.

This section is foundational. Many people start with frameworks and tool invocation right away, but if they do not understand the capability boundaries of LLMs, they can later overcomplicate agents and attribute too much to the model.

2. Classic Agent Paradigms and Framework Practices

A major part of the project introduces and implements classic agent paradigms, such as:

• ReAct: the loop between reasoning and action.
• Plan-and-Solve: plan first, execute step by step.
• Reflection: let the model reflect on and correct its own output.
• Tool calling and interaction with external environments.
• Framework-based agent development practices.

These topics are important for understanding what an agent truly is. An agent is not just sending the user question to a model; it is designing a loop where the model observes state, generates a plan, selects tools, executes actions, receives results, and continues reasoning.

3. Low-Code Platforms and Mainstream Frameworks

Hello-Agents also introduces low-code platforms such as Coze, Dify, and n8n, as well as mainstream agent frameworks like AutoGen, AgentScope, and LangGraph.

The value here is that learners can see both routes at once. One route is productized and process-oriented, suitable for rapid application assembly. The other is code-oriented and framework-oriented, suitable for deeper engineering control.

For beginners, there is no need to debate which framework to choose at the very beginning. The more important thing is understanding shared underlying issues first: how to decompose tasks, how to integrate tools, how to maintain state, how to handle failures, and how to compress context.

4. Memory, RAG, and Context Engineering

When agents move from simple Q&A to complex tasks, memory and context management become critical. Hello-Agents includes content on memory systems, RAG, storage, and context engineering.

This part is especially worth studying carefully because many agent demos look impressive but quickly run into problems in real use:

• Conversation history gets too long and the model starts forgetting key points.
• Tool responses are too verbose, and the model misses the signal.
• State is lost across many turns.
• Retrieval results are unstable.
• Context window and cost become hard to control.

These issues are fundamentally about context engineering. Whether you can organize information well often matters more than switching to a larger model.

5. End-to-End Projects and Multi-Agent Applications

Hello-Agents also includes integrated practice projects, such as intelligent travel assistants and Cyber Town case studies. The value of these projects is not only in showing results, but in helping learners see how an agent system evolves from modules to a complete system.

When an agent needs to handle real tasks, it is usually no longer a single function call; it spans user input, task planning, external tools, memory systems, error handling, and result presentation. Studying through full examples makes the engineering complexity of agent systems much easier to understand.

4. Why This Project Is Worth Attention

In my view, Hello-Agents is worth attention for three reasons.

1. It Does Not Only Discuss Concepts; It Emphasizes Hands-On Practice

There are already many conceptual articles on AI Agents, but concepts alone easily create the illusion that an agent is merely "model + tool calling." In practice, the real complexity lies in engineering details such as message structure, tool return formats, exception handling, context compression, memory updates, and multi-turn execution control.

Hello-Agents is practice-oriented. It does not just tell you what an agent is; it guides you to build, run, and understand a system step by step.

2. It Helps Chinese Learners Enter the Field Systematically

Many Agent learning materials are scattered across English docs, papers, GitHub examples, and framework guides. For Chinese learners, the issue is not the absence of material but the lack of a coherent learning path.

As a Chinese-language open tutorial, Hello-Agents places agent fundamentals, LLM basics, classic paradigms, framework practice, advanced topics, and capstone projects in one coherent system, lowering the barrier for structured entry.

3. It Helps Learners Develop Engineering Mindset

An agent is not mysticism, and not just prompt craftsmanship. It is closer to software system construction around a large language model.

When learning agents, one should gradually build the following engineering mindset:

• The model is part of the system, not the whole system.
• Prompts matter, but state management, tool design, and error handling matter too.
• A demo running does not guarantee a reliable system.
• RAG, memory, tool use, and context engineering all require deliberate design.
• A truly valuable agent usually comes from concrete scenarios rather than generic conversation.

Hello-Agents is well aligned with helping learners shift from "model worship" to "system building."

5. Suggested Learning Path

If you are new, do not try to rush through all chapters. You can follow this route:

1. Start by Understanding Core Concepts

First, study agent definitions, development history, and LLM fundamentals. At this stage, do not rush into complex code. The focus should be understanding why agents appeared, what problems they attempt to solve, and how they differ from ordinary chatbots.

2. Then Learn ReAct and Tool Use

Mastering ReAct and Tool Use is a key step in understanding agents. You need to understand when the model should answer directly, when it should call a tool, how tool results are returned to the model, and how the model continues reasoning based on those results.

3. Then Add RAG, Memory, and Context Engineering

Once you can write a simple agent, continue with RAG, memory systems, and context engineering. These determine whether an agent can handle longer, more complex tasks that resemble real-world scenarios.

4. Finally Study Multi-Agent Systems and Capstone Projects

Multi-agent systems sound advanced, but learning them too early is not recommended. First, understand a single agent's input, output, tools, state, memory, and context; only then will multi-agent collaboration make much more sense.

6. How to Apply It to Your Own Projects

If you are building personal websites, knowledge bases, automation tools, or AI learning projects, Hello-Agents offers many transferable ideas.

For example, you can apply its learning approach to areas such as:

• Building intelligent retrieval and Q&A for site articles.
• Adding LLM explanation features to your tool pages.
• Creating a personal assistant that can call multiple APIs.
• Organizing your Markdown, PDFs, notes, and codebases with RAG.
• Designing an agent workflow for a specific domain.
• Learning how to break complex tasks into multiple executable steps.

The truly valuable way to learn is not to copy tutorial code verbatim, but to transplant the underlying ideas into your own projects. For example, on a personal website, an agent can be more than a chat widget: it can be an article assistant, search assistant, code explainer, date-picker explanation assistant, or even an automatic content curation workflow.

If you already know what you want to build, the remaining decision is often which language to implement it in. You can refer to “What Language to Use for AI Agents: Python, TypeScript, and Next-Gen Product Engineering”.

7. Copyright Notice

This article is intended only for introduction, learning, and sharing the Datawhale Community Hello-Agents project. The original content, code, documentation, and related copyrights belong to the original author(s) and the Datawhale community.

According to the publicly available license in the project repository, Hello-Agents uses the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) license. When reproducing, citing, or adapting related content, please preserve the original author attribution, original project link, and license terms, and comply with the non-commercial and share-alike requirements.

This site provides only introductory content and educational materials and does not claim ownership of the original project copyright, nor does it represent the official position of Datawhale. If the author or the community believes there is an issue with this article, please contact this site for modification or removal.

FAQ

Who Should Learn Hello-Agents?

It is suitable for people who want to systematically understand AI Agent principles, are not satisfied with isolated blog posts, already know how to use ChatGPT/Claude/Gemini, have some Python or programming foundation, and especially want to progress from "tool users" to "agent application builders."

What Is the Difference Between Hello-Agents and Coze, Dify, n8n?

Coze, Dify, and n8n are low-code process orchestration tools suitable for quickly assembling an application. Hello-Agents focuses more on AI-native agents, teaching how the model plans, reasons, invokes tools, maintains memory, and self-corrects. Its path runs from core principles to code implementation.

What Prerequisites Are Needed to Learn Hello-Agents, and How Should I Learn It?

A bit of Python or programming background is enough. A recommended progression is: first understand agent definitions and LLM basics, then learn ReAct and tool calling, then add RAG, memory, and context engineering, and finally study multi-agent systems and integrated projects.

Is Hello-Agents Free? Can It Be Reposted?

It is a Datawhale community open-source tutorial under CC BY-NC-SA 4.0 and can be studied for free. When reprinting, citing, or adapting, please retain the original author attribution and project link, and comply with the non-commercial and share-alike terms.

Sources

• Hello-Agents GitHub Repository
• Hello-Agents Online Reading
• Hello-Agents Mainland China Accelerated Reading
• Hello-Agents License
• Datawhale GitHub Profile