Open Source Project Recommendation: Agent-Learning-Hub —— A Systematic Learning Roadmap and Resource Library for Building Reliable AI Agents

The AI Agent learning roadmap and resource library produced by DataWhale, systematically organizing official documentation, top conference papers, open-source projects, and engineering practices to help developers build practical and reliable AI agents from scratch. Avoid fragmented learning — get an executable growth path directly.

Core Highlights:

1. Learning Todo List: 8 stages (from understanding the Agent loop → building a minimal Agent → evaluation & safety), step-by-step from foundations to production level
2. Project Ladder: 11 progressive projects (from a simple calculator Agent to a production-level personal Agent), learn by doing
3. Curated Resources: Official guides from Anthropic/OpenAI/Google, papers like ReAct/SWE-bench, open-source projects like Claude Code/OpenClaw/LangGraph, and modern skill protocols like MCP/A2A/ACP
4. Claude Code Dedicated Path: official docs + replica projects + source code analysis, focusing on harness engineering and tool calling
5. Focus on Modern Agent Directions (Claude Code, Skills, RAG, multi-agent), rejecting outdated frameworks

Currently has 3.9k+ stars, active community, continuously updated. It’s a complete roadmap for “how to systematically learn to build tools”. After completing it, you’ll better understand, customize, and build your own AI Agent workflows.

Especially suitable for developers, graduate students, and AI learners who want to systematically master AI Agent engineering from scratch.

https://github.com/datawhalechina/Agent-Learning-Hub…

#AIAgent #ClaudeCode #AI教程 #codex #开源项目

datawhalechina/Agent-Learning-Hub

Source: https://github.com/datawhalechina/Agent-Learning-Hub

Agent Learning Hub

A curated AI Agent learning roadmap for people who want to build useful, reliable agents instead of collecting random links.

This repo only maintains one core display: README. The goal is to organize excellent shares from the community, official blogs, papers, open-source projects, and real engineering experience into an actionable AI Agent learning todo list.

Maintainer

Curated by 陈思州 (https://github.com/jjyaoao) (Datawhale member)

How To Use

• If you’re a beginner: follow the “Learning Todo List” from top to bottom, check off each item.
• If you already know LLM applications: start from Stage 2 or Stage 3, focus on Agent loop, tool calling, evaluation, and engineering.
• If you want to build projects: directly go to “Project Ladder” and build a working project for each level.
• If you only want to find resources: check “Curated Resources”, prioritize official docs and classic papers.

What To Learn Now

The agent field changes quickly. What’s worth investing in now is not the old “role-playing multi-agent framework”, but these directions closer to real productivity:

It is not recommended to heavily invest in old crew/role-play frameworks that have become generic templates. They can be understood, but should not be the main line.

Learning Todo List

Stage 0: Understand What An Agent Is

• Distinguish chatbot, workflow, agent, multi-agent.
• Understand the basic agent loop: observe -> think -> act -> observe.
• Know when not to use an agent: when the task is predictable, the process is stable, or a normal script can solve it — using an agent adds uncertainty.
• Read Anthropic: Building effective agents (https://www.anthropic.com/engineering/building-effective-agents).
• Read OpenAI: A practical guide to building agents (https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/).

Output: Write a one-page short note answering “Why does my scenario need an agent instead of a normal workflow?”

Stage 1: Build A Minimal Agent Loop

• Use an LLM API for normal conversation.
• Make the model output structured JSON.
• Define a tool function, e.g., search, calculator, read_file.
• Parse the model’s tool call / function call.
• Execute the tool and feed the tool result back to the model.
• Add max steps, timeout, and error handling to the agent loop.

Recommended reading:

• OpenAI Function Calling (https://platform.openai.com/docs/guides/function-calling)
• Gemini API Function Calling (https://ai.google.dev/gemini-api/docs/function-calling)
• Claude Tool Use (https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview)

Output: A minimal agent of 50-150 lines that can select tools, execute them, and return the final answer.

Stage 2: Learn Tool Use, RAG, And Memory

• Do retrieval augmented generation: chunk, embed, retrieve, answer with citations.
• Connect search, database, file, browser, code execution as tools.
• Differentiate short-term context, session memory, long-term memory.
• Handle tool failures, empty results, repeated calls, hallucinated citations.
• Make the agent provide sources or evidence in its answer.

Recommended reading:

• LlamaIndex Agents (https://docs.llamaindex.ai/en/stable/use_cases/agents/)
• LangChain Docs (https://docs.langchain.com/)
• Gemini API Code Execution (https://ai.google.dev/gemini-api/docs/code-execution)
• Model Context Protocol (https://modelcontextprotocol.io/)

Open-source project references:

Output: A research assistant that automatically searches, filters, summarizes, and outputs cited links given a topic.

Stage 3: Study One Modern Agent Harness

First, pick one modern agent system to study in depth. The focus here is not “how to call the framework API”, but how it organizes tools, context, permissions, state, logs, subtasks, and feedback.

• Read the directory structure of an agent harness.
• Identify its agent loop, tool registry, permission gate, session store, context compaction.
• Run its minimal example and add your own tool.
• Observe a complete trace, explain why each step happens.
• Implement the same task with both a “bare agent loop” and the “harness”, compare the differences.

Output: A debuggable agent harness demo, including README, run steps, example input/output, and failure logs.

Stage 4: Multi-Agent Is Coordination, Not Magic

• Understand common roles: planner / executor / reviewer / critic / router.
• Learn to manage multiple agents using a supervisor or graph, not just letting agents chat randomly.
• Define each agent’s responsibility boundary, input/output schema, and stopping condition.
• Handle loops, arguments, task drift, context bloat.
• Determine when a single agent is better.

Recommended reading:

• Claude Code Subagents (https://code.claude.com/docs/en/sub-agents)
• Claude Code Hooks (https://code.claude.com/docs/en/hooks)
• Google Agent Development Kit (https://google.github.io/adk-docs/)
• Agent2Agent Protocol (https://a2a-protocol.org/latest/specification/)
• Agent Client Protocol (https://agentclientprotocol.com/)

Output: A small multi-agent system, e.g., research -> write -> review -> revise.

Stage 5: Learn Skills, Protocols, And Capability Packaging

Modern agent capabilities come not only from models and tools but also from reusable skills. A good skill is like a small operating manual: tells the agent when to use it, how to use it, which scripts/resources are needed, and how to verify results.

• Understand the difference between Skill and Tool: a tool is a callable interface, a skill is reusable process knowledge.
• Understand the difference between Skill and Prompt: a prompt is usually a one-time instruction, a skill is a discoverable, versioned, and distributable capability package.
• Understand the difference between Skill and MCP: MCP connects external tools/data sources, a skill tells the agent how to complete a class of tasks.
• Read Claude Code Skills file structure and trigger mechanism.
• Read OpenClaw Skills loading, scope, and security boundaries.
• Write a minimal SKILL.md, containing name, description, when to use, steps, acceptance criteria.
• Add a script or template file to the skill, and explain when the agent should load it.
• Write a smoke test for the skill to verify if it truly improves task success rate.

Recommended reading:

• Claude Code Skills (https://code.claude.com/docs/en/skills)
• Claude Agent Skills (https://docs.claude.com/en/docs/agents-and-tools/agent-skills)
• Claude Code Agent SDK Skills (https://code.claude.com/docs/en/agent-sdk/skills)
• OpenClaw Skills (https://github.com/openclaw/openclaw/blob/main/docs/tools/skills.md)
• Model Context Protocol (https://modelcontextprotocol.io/)
• Agent2Agent Protocol (https://a2a-protocol.org/latest/specification/)
• Agent Client Protocol (https://agentclientprotocol.com/)

Output: A reusable skill, e.g., code-review, research-report, migration-helper, pdf-extraction, or release-note-writer.

Stage 6: Browser And Computer-Use Agents

• Understand the difference between a browser agent and a normal API tool.
• Use Playwright or browser-use for web observation and clicking.
• Add security restrictions to browser operations: not logging into sensitive accounts, not overstepping permissions, not bypassing platform rules.
• Handle page changes, popups, load failures, element location failures.
• Record screenshots, DOM, action logs for review.

Recommended reading:

• Claude Computer Use (https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/computer-use-tool)
• browser-use (https://github.com/browser-use/browser-use)
• WebArena (https://arxiv.org/abs/2307.13854)
• VisualWebArena (https://arxiv.org/abs/2401.13649)

Output: A browser agent that only operates on public web pages, e.g., opening a page, extracting information, generating a summary.

Stage 7: Evaluation, Observability, And Safety

• Prepare a fixed test set for the agent, not just watch demos.
• Record success rate, failure reasons, tool call count, cost, latency.
• Read traces, know if failure occurs in prompt, tool, retrieval, model, or state management.
• Add human confirmation for dangerous tools, e.g., sending emails, deleting files, making payments, publishing content.
• Understand risks like prompt injection, data exfiltration, tool abuse.
• Use regression tests to prevent capability degradation after prompt or tool changes.

Recommended reading:

• OpenAI Evals (https://platform.openai.com/docs/guides/evals)
• OpenAI Agent platform (https://openai.com/agent-platform/)
• LangSmith (https://docs.smith.langchain.com/)
• AgentBench (https://arxiv.org/abs/2308.03688)
• SWE-bench (https://arxiv.org/abs/2310.06770)

Output: An agent eval table with at least 20 tasks, expected results, actual results, failure classification.

Stage 8: Ship A Real Agent

• Has a clear user, clear task, clear success criteria.
• Has logs, traces, error retries, timeout, cost limit.
• Has permission boundaries and human confirmation mechanisms.
• Has a deployment method: CLI, Web app, Slack bot, GitHub Action, or background task.
• Has a README: how to run, how to configure keys, how to extend tools, what limitations.

Output: An agent project that others can clone and run.

Project Ladder

Curated Resources

Official Guides And Blogs

Project Map

Don’t read projects by star count randomly; suggest layering by learning purpose:

Skills, Protocols, And Tooling

Modern Agent Systems