Hello Agents
Free 16-chapter Datawhale open-source tutorial that teaches you to build AI agents from scratch in Python, including your own HelloAgents framework.
For a Python developer who wants to genuinely understand agent internals, this is the most complete free curriculum we've found, and chapter seven — building your own HelloAgents framework on the OpenAI native API — is what makes the rest stick. Chapters eight through twelve cover memory and RAG, context engineering, MCP/A2A/ANP, SFT-to-GRPO Agentic RL and evaluation, ground that most paid courses gloss over. If your goal is to ship an agent this week, go to LangChain or CrewAI instead; if your goal is to understand why those frameworks are built the way they are, work through this first. The whole thing is free under CC BY-NC-SA 4.0, so you can read it, run the code, and teach from it —
Verified 2d ago · liveness 60/100 · cite: rightaichoice.com/tools/hello-agents
- Python developers who want a systematic, from-scratch understanding of agent internals
- Engineers building a custom agent framework instead of adopting an existing SDK
- AI educators and students who need a complete, free, openly licensed curriculum
- Researchers working on Agentic RL (SFT to GRPO) and multi-agent communication protocols
- Teams that need a ready-to-use agent product with hosting or support
- Absolute beginners with no Python and no prior LLM API experience
- Practitioners who want a quick working demo rather than a full curriculum
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Hello-Agents if you need a working agent this week — it is a 16-chapter curriculum you work through, not an SDK you install, and the later chapters assume you are willing to build and debug your own framework first.
The tutorial is free, but chapter eleven's Agentic RL pipeline (SFT through GRPO) requires GPU compute you pay for yourself — budget for training runs the curriculum does not provide.
Hello-Agents itself is free to read and download, which puts it below paid agent courses and paid framework bootcamps in cost and above them in scope. The real cost comparison is time plus compute: you spend weeks working through 16 chapters and you pay for whatever LLM API calls and GPU time your projects consume. Against a managed platform subscription, you are trading recurring fees for your own engineering hours.
In short
Hello Agents — Free 16-chapter Datawhale open-source tutorial that teaches you to build AI agents from scratch in Python, including your own HelloAgents framework. Best for Python developers who want a systematic, from-scratch understanding of agent internals, Engineers building a custom agent framework instead of adopting an existing SDK, AI educators and students who need a complete, free, openly licensed curriculum. Free to use.
What people actually say about Hello Agents — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
62 mentions across 4 sources (YouTube, Bluesky, GitHub, Lemmy) · researched Jul 18, 2026.
Average across the 4 sources that answered — each source counts once, not each post.
- +Free and open-source with permissive license.
- +Covers agent fundamentals from scratch without platform lock-in.
- +Hands-on code examples and real projects.
- +Large, active Datawhale community on GitHub (66,922 stars).
- +Covers memory, tools, planning, and multi-agent systems.
- −Frequent code errors and broken examples in early chapters.
- −Cloud services (Neo4j, Qdrant) often misconfigured out of the box.
- −No official support or dedicated forum for troubleshooting.
- −Some chapters timeout with popular LLMs due to no tool calls.
- −Real-world use cases are not clearly demonstrated.
- • Time spent debugging broken examples
- • Potential cloud service costs (Neo4j, Qdrant) if following integrations
Viability Score
How well maintained and how widely used is Hello Agents? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- 16-chapter open-source tutorial on building AI agents from scratch
- Hands-on Python implementation of ReAct, Plan-and-Solve and Reflection
- Build your own HelloAgents framework on the OpenAI native API
- Memory systems, retrieval and RAG integration (chapter eight)
- Context engineering for sustained multi-turn agent interaction (chapter nine)
- Agent communication protocols explained: MCP, A2A, ANP (chapter ten)
- Agentic RL training pipeline from SFT to GRPO (chapter eleven)
- Agent performance evaluation with core metrics, benchmarks and frameworks
- Walkthroughs of low-code agent platforms: Coze, Dify, n8n (chapter five)
- Mainstream framework practice: AutoGen, AgentScope, LangGraph (chapter six)
- Project: smart travel assistant with MCP and multi-agent collaboration
- Project: automated deep-research agent reproduction and analysis
- Project: cyber town multi-agent social simulation
- Community Extra-Chapter with agent interview questions and answers
- Complete companion code in the repository code folder
About Hello Agents
Hello-Agents is a free, open-source Datawhale community tutorial that walks you through building AI agents from first principles in Python. It is written for developers, software engineers, students and self-learners who already know basic Python and have called an LLM API at least once, and who want to understand what actually happens inside an agent rather than just wire up someone else's SDK. The project deliberately targets AI-native agents, in contrast to workflow-driven, low-code builders such as Coze, Dify and n8n. The curriculum runs across five parts and 16 chapters. It opens with agent definitions and history plus LLM fundamentals (Transformer, prompting, model limits), then moves into hands-on code: you implement ReAct, Plan-and-Solve and Reflection yourself in chapter four, try low-code platforms in chapter five, and work through AutoGen, AgentScope and LangGraph in chapter six. Chapter seven is the pivot point — you build your own lightweight framework, HelloAgents, on the OpenAI native API, so the later chapters run on code you wrote. Part three covers what most paid courses skip: memory systems and RAG, context engineering, agent communication protocols (MCP, A2A, ANP), an Agentic RL pipeline from SFT to GRPO, and agent evaluation with metrics and benchmarks. Part four turns that into projects — a smart travel assistant using MCP and multi-agent collaboration, a reproduction of an automated deep-research agent, and a cyber town multi-agent social simulation. Chapter 16 is a graduation design: your own complete multi-agent application. Everything is free to read online (with a China accelerator mirror), downloadable as a PDF watermarked with the Datawhale logo to discourage resale, and licensed CC BY-NC-SA 4.0. All companion code ships in the repo's code folder. A community Extra-Chapter adds agent interview questions and answers, GUI agent and web agent walkthroughs, agent self-evolution, Agent Skills versus MCP, Dify setup guides, and community-recorded video lessons.
Behind the Verdict
Hello-Agents is best understood as a curriculum, not a product. There is no managed runtime, no endpoint to call, and nothing to integrate — you get text, code, and a PDF. That framing matters, because most tools in this category are SDKs with docs attached, whereas this is docs with code attached. What it does well: the sequencing is deliberate. Chapters one through three give you the vocabulary (agent definitions, the shift from symbolic systems to LLM-driven agents, Transformer and prompting basics) before chapter four asks you to hand-implement ReAct, Plan-and-Solve and Reflection. Chapter five has you poke at Coze, Dify and n8n so you know what low-code buys you, and chapter six does the same for AutoGen, AgentScope and LangGraph. Then chapter seven flips the switch: you build HelloAgents on the OpenAI native API, and every subsequent chapter — memory and RAG, context engineering, MCP/A2A/ANP, Agentic RL from SFT to GRPO, evaluation — runs on your own code. That is a genuinely unusual structure. Most tutorials teach you to consume a framework; this one makes you own one first, which is the fastest way to stop treating a framework as magic. The project casework is where it earns its keep for portfolio purposes: a travel assistant using MCP and multi-agent collaboration, a reproduction and analysis of an automated deep-research agent, and a cyber town social simulation. Chapter 16 is an open graduation design rather than a guided exercise. The Extra-Chapter is a real asset and easy to miss. It collects agent interview questions with answers, GUI agent and web agent practical walkthroughs (including anti-scraping notes and HelloAgents integration for the web agent), agent self-evolution's four closed-loop categories, an Agent Skills versus MCP comparison, a step-by-step Dify agent build, environment configuration, and community-recorded video lessons covering ReAct/Plan-and-Solve/Reflection, Coze, LangGraph, context engineering and the deep-research agent. Where it is weak: it is not a shortcut. The limitations section below is not boilerplate — the tutorial assumes both Python fluency and prior LLM API experience, and the advanced chapters are reproductions of existing systems rather than production blueprints. Several chapters are intellectually valuable and operationally useless if your deadline is Friday. Content cadence tracks community contribution, since the project says its updates depend on contributors. And CC BY-NC-SA 4.0 means you cannot lift the text into a commercial product — it is a teaching resource and a portfolio artifact, not a component. Our read: pair it with a shipping framework rather than choosing between them. Learn the internals here over a few weeks, then build your actual product on LangGraph or CrewAI where the maintenance burden is someone else's problem. If you are an educator, the 16-chapter structure and the watermarked PDF are directly usable under the license.
Researching Hello Agents? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Hello Agents actually fits — and what changes day-one when you adopt it.
You read chapters one through six to get the vocabulary and framework landscape, implement ReAct and Reflection in chapter four, then work the Extra-Chapter agent interview question set alongside the main text.
Outcome: You can explain and code the classic agent loops from memory instead of reciting framework API names, and you walk into the interview with working code in your repo.
You go straight to chapter seven and build HelloAgents on the OpenAI native API, then use chapters eight through twelve to bolt on memory and RAG, context engineering, MCP/A2A/ANP communication, and an evaluation harness.
Outcome: You own a lightweight framework you understand end to end, which you can extend or replace piece by piece instead of adopting an SDK wholesale.
You adopt the 16-chapter structure as your syllabus, hand students the watermarked PDF and the code folder, and use the community-recorded video lessons for the ReAct, Coze and LangGraph sessions.
Outcome: You ship a full agent-development course without authoring the curriculum, within the bounds of the CC BY-NC-SA 4.0 non-commercial license.
Use Cases
- Learn agent architecture end to end before committing to a production framework
- Implement ReAct, Plan-and-Solve, or Reflection by hand to see how each one actually works
- Build a custom lightweight agent framework on the OpenAI native API (chapter seven)
- Add memory, retrieval and RAG to a personal agent project
- Design multi-agent communication using MCP, A2A, or ANP
- Run an Agentic RL training pipeline from SFT through GRPO
- Prepare for agent-engineering job interviews using the community question set
- Teach an agent-development course using the 16-chapter structure and the PDF
Models Under the Hood
as of 2026-08-31
Limitations
- Hello-Agents is a tutorial, not a service.
- It ships no managed hosting and no support contract, so you deploy and integrate everything you learn yourself.
- The project states its updates depend on community contributions, so content cadence follows contributor availability.
- It assumes basic Python and a working idea of how to call an LLM through an API; without those the code chapters will be rough going.
- Several advanced chapters — the deep-research agent, for instance — are reproductions of existing systems rather than production blueprints.
- Chapter eleven's Agentic RL pipeline from SFT to GRPO needs real compute, which the tutorial does not provide.
- The material is licensed CC BY-NC-SA 4.0, which restricts commercial reuse of the text and code.
as of 2026-10-16
Verification history
We have re-verified Hello Agents 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Hello Agents tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free
$0
Ideal for
Python developers, students and educators who want the full 16-chapter curriculum plus the code folder without paying for a course or a platform subscription.
What this tier adds
Starting tier — everything the project publishes: online reading, China mirror, watermarked PDF, companion code, Extra-Chapter and community video lessons, under CC BY-NC-SA 4.0.
Where the pricing makes sense
The company stage and team size where Hello Agents's pricing actually pencils out — and where peers do it cheaper.
Hello-Agents itself is free to read and download, which puts it below paid agent courses and paid framework bootcamps in cost and above them in scope. The real cost comparison is time plus compute: you spend weeks working through 16 chapters and you pay for whatever LLM API calls and GPU time your projects consume. Against a managed platform subscription, you are trading recurring fees for your own engineering hours.
Setup time & first value
How long it actually takes to get something useful out of Hello Agents — broken out by persona, not the marketing-page minute.
Reading-only path: minutes — open the online version (or the China accelerator mirror) and start chapter one, no account required. Coding path: about an hour to clone the repo, install dependencies from the code folder and get your first ReAct loop running from chapter four. Full framework-to-project path: days to weeks, with chapter seven's HelloAgents build being the natural checkpoint before
Switching to or from Hello Agents
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From LangChain or CrewAI tutorials: read chapters four and six first to see the same patterns implemented by hand, then chapter seven to understand the framework layer you were previously importing.
- →From a low-code builder like Coze or Dify: chapter five meets you where you are, then chapters four and seven move you from configuring a workflow to writing the agent loop yourself.
- →From scattered blog posts and video walkthroughs: use the 16-chapter table of contents as the spine and fill gaps in the order the book lays out, since later chapters assume the chapter-seven framework exists.
- ↗To LangGraph or AutoGen for production: take the architecture you built in chapter seven and rebuild it on a maintained framework once you know which parts you actually need.
- ↗To a managed agent platform: the evaluation material in chapter twelve gives you metrics to compare a hosted product against your own build before you switch.
- ↗To shipping your own multi-agent app: chapter sixteen's graduation design is the intended handoff point from curriculum to your own product.
Resources & Guides
- Resourcehello-agents.datawhale.cc
Home · Hello Agents
Helpful link from hello-agents.datawhale.cc
- Resourcegithub.com
Latest · Hello Agents
Helpful link from github.com
- Learndatawhale.cn
239 · Hello Agents
Educational content from datawhale.cn
- Resourcegithub.com
Hello Agents · Hello Agents
Helpful link from github.com
Tutorials & Learning
YouTube returned 6 videos for “Hello Agents”, and we withheld 6: 6 did not mention Hello Agents. We are showing none, because we could not prove any of them are about Hello Agents.
Official links
Tools that pair well with Hello Agents
Common stack mates teams adopt alongside Hello Agents, with the specific reason each pairing earns its keep.
OpenAI Agents SDK
A free, MIT-licensed Python framework from OpenAI for building multi-agent workflows with handoffs, guardrails, and tracing.
Mastra
Mastra is an open-source TypeScript agent framework for durable agents, typed workflows, and built-in evals.
SmolAgents
SmolAgents is Hugging Face's open-source Python library for building code-writing AI agents in a few lines of code.
Featured Head-to-Head Comparisons
Hello Agents vs Truleo
Choose Truleo if you are a law enforcement agency needing to connect siloed data and automate lead generation—it's purpose-built with integrations to RMS, CAD, jail calls, and body cameras. Choose Hello Agents if you are a developer or student wanting to learn how to build AI agents from scratch for free. They serve completely different needs; no direct competition.
Hello Agents vs Praktika
These tools serve completely different purposes. Praktika is for language learners seeking AI-powered speaking practice; Hello Agents is an educational resource for developers building AI agents. Choose based on your goal: language fluency or AI development skills.
Hello Agents vs Presto Voice
Presto Voice is a proven enterprise solution for QSR chains wanting to automate drive-thrus and boost revenue, backed by recent partnerships like Dairy Queen. Hello Agents is a free, open-source educational resource for developers learning to build AI agents from scratch. Choose Presto Voice if you need a ready-to-deploy commercial system; choose Hello Agents if you want to understand agent fundamentals and code your own.
Alternatives to Hello Agents
View all
OpenAI Agents SDK
A free, MIT-licensed Python framework from OpenAI for building multi-agent workflows with handoffs, guardrails, and tracing.
Mastra
Mastra is an open-source TypeScript agent framework for durable agents, typed workflows, and built-in evals.
SmolAgents
SmolAgents is Hugging Face's open-source Python library for building code-writing AI agents in a few lines of code.
Frequently Asked Questions
Best-of guides
Used Hello Agents? Help shape our editorial sentiment research.