# agentic-ai: a course translation with conflicting licences

> agentic-ai is a Datawhale community project translating Andrew Ng's Agentic AI course series from DeepLearning.AI into Chinese, split across five module directories with named owners and a four-layer concept-to-code structure. The repository's licence metadata says Apache-2.0 while its own README says CC BY-NC-SA 4.0, which is a difference that matters a great deal to anyone considering commercial use.

**datawhalechina/agentic-ai** — 本项目围绕吴恩达老师在DeepLearning.AI出品的Agentic-ai系列课程，为学习者打造中文翻译与知识整理教程。项目提供课程内容翻译、知识点梳理和示例代码解读等内容，欢迎大家Star!

- Repository: https://github.com/datawhalechina/agentic-ai
- Stars: 1,304 · Forks: 217
- Language: Jupyter Notebook
- License: Apache-2.0
- Published: 2026-09-30 · Updated: 2026-09-30 · Language: en
- Canonical page: https://hysenlabs.com/projects/datawhalechina-agentic-ai

## Apache-2.0 in the metadata, CC BY-NC-SA in the README

This repository declares two different licences, and the difference between them is the difference between commercial use and no commercial use.

The repository-level licence metadata reads Apache-2.0. The README's own License section, at the very bottom of the file, says the work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Licence, and it displays a badge reading CC BY-NC-SA 4.0 with the Chinese description 知识共享许可协议. The full Chinese name given is 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议, which spells out the three conditions: attribution, non-commercial use, and share-alike.

So there is a LICENSE file at the repository root, there is a badge in the README, and there is a licence field in the repository metadata, and the first two agree with each other and the third disagrees with both.

The practical consequences are not subtle. Under Apache-2.0 you may use the material commercially, modify it, sublicense it and distribute it, with attribution and a patent grant. Under CC BY-NC-SA 4.0 you may share and adapt it, with attribution, but only for non-commercial purposes, and any adaptation must be distributed under the same licence. So a company building a commercial training product, an internal platform for staff, or a paid course that incorporates these translations has a clear answer under one declaration and a clear prohibition under the other.

Which one governs in practice is a question for whoever wrote the project, and the LICENSE file is the document to read. But the asymmetry matters even before you resolve it. A machine reading the repository metadata sees a permissive software licence and concludes that the material is freely usable. A machine reading the README sees a non-commercial restriction. A human skimming the badges sees the CC badge and a human reading the repository page sees Apache-2.0. Whichever one a downstream user happens to consult, they get a different answer, and one of those answers is wrong.

There is an additional consideration that makes the CC BY-NC-SA choice look deliberate rather than accidental, and therefore makes the metadata error more consequential. The source material is a course from DeepLearning.AI, which is a commercial education company, and the course is the intellectual property of its author and its institution. A community translation of a commercial course is not in the same position as a translation of an open-source project's documentation: the translator does not hold the rights to the underlying material, and the course's own terms are a separate constraint that no licence on the translation can override.

Given that, a non-commercial, share-alike licence on the translations is the sensible and careful choice. It signals that the project is not attempting to compete with the course, and it stops anyone from taking a Chinese translation of a paid course and reselling it. The metadata saying Apache-2.0 is therefore not just an inconsistency, it is an inconsistency that understates the restriction the project chose, in the one field that automation reads.

Fixing it is a one-line change to the repository metadata, and until it is made, the README and the LICENSE file are the documents to trust.

## The friendly-links section links to this repository

The 项目友链 section, which lists related projects, contains a link to this repository, described as something other than what this repository is.

The first friendly link is bolded as agentic-ai, and its description says it covers the concept, usage, code practice and course content of Agent Skills, helping learners study how to create an Agent Skills setup that suits them. The URL behind that link is github.com/datawhalechina/agentic-ai.

That is this repository. The repository being documented is datawhalechina/agentic-ai, and this README is datawhalechina/agentic-ai's README.

So the project's list of related resources includes itself, under a description of a different project's subject matter. The description talks about Agent Skills specifically, while this repository's own README describes itself as a translation and knowledge-organisation of Andrew Ng's Agentic AI course series, broken into five modules on agentic workflows, reflection design patterns, tool use, practical tips, and patterns for highly autonomous agents.

Two readings are possible and the README does not say which applies. Either the friendly link was meant to point at a different repository that does not exist yet under that name, and someone pasted the wrong URL or trimmed a character from it. Or there were meant to be two related repositories, one for the Agent Skills material and one for the course translation, and one of them was merged, renamed, or never created.

The near-miss in the naming is what makes this look like a copy error rather than a deliberate self-link. The Datawhale organisation has a repository called agentic-ai, which is this one, with a hyphen, and the friendly link's text reads agentic-ai as well. The description's subject, Agent Skills, is a distinct concept from the course's five modules. So a reader following the link expects a different body of content and arrives here.

That is a small defect, and it is the kind that survives because friendly-links sections are written once when a project starts and never revisited. It matters slightly more than usual here because the second friendly link is well done by comparison: ai-prompting-for-everyone is described accurately as an introductory course that is not about complex model internals but about how ordinary users can ask AI better questions, state tasks clearly, and get answers that better match what they needed. That is a real description of a real sibling project, and it shows the section was written with care. One link being wrong in a section where the other is right is a slip rather than a pattern.

The fact that the two friendly links are the sibling projects is worth noting as the actual structure of Datawhale's course-translation work. There is a family here: this course, an Agent Skills project, and an introductory prompting course. A reader who wants the prerequisite will find it linked from here, which is the useful part of the section, and a reader who wants Agent Skills specifically will find the wrong repository, which is the useless part.

## Five module directories whose names will break your scripts

The top-level directory listing of this repository is five module directories, and every one of them has a name that will cause trouble in a script.

The five are:

```text
1. Agentic工作流简介[Introduction to Agentic Workflows]
2. 反思设计模式[Reflection Design Pattern]
3. 工具使用[Tool Use]
4. 构建Agentic AI的实用技巧[Practical Tips for Building Agentic AI]
5. 高度自治智能体的模式[Patterns for Highly Autonomous Agents]
```

Each name begins with a digit and a period, then Chinese characters, then the English title inside square brackets. So a single path component contains a leading period, a space, a CJK run, another space, an ASCII run, an opening bracket and a closing bracket.

The period at the start is the sharpest edge. A component beginning with a dot is a hidden file to every Unix tool by default, so a glob that excludes dotfiles excludes the module directories, and a script that uses os.listdir sees them while a script that uses a shell glob does not. That inconsistency is the kind of thing that produces a report of an empty repository on one machine and a full one on another.

The square brackets are the second problem, and they are the classic one. In a shell, a bracket expression is a glob character class, so a path containing `[Introduction to Agentic Workflows]` is not a literal path; it is a pattern, and it will either fail to match or match something else. Any makefile rule, any shell script, any CI configuration that references these paths has to escape the brackets, and the majority of such references are written without escaping.

The spaces are the third and least surprising, since quoting handles them, but they combine badly with the brackets: quoting a path with brackets in it inside a makefile is a genuinely fiddly exercise, and the natural thing to do is to give up and copy the file.

The CJK characters are not a problem for the filesystem, since they are valid UTF-8 path components, but they are a problem for anything that assumes ASCII paths: a build script that builds an identifier from a directory name, a tool that generates anchors or slugs, and any URL that has to reference the directory without percent-encoding. GitHub renders the links fine because it encodes them, so the problem only appears once you leave the web interface.

None of this means the naming is wrong. For a human-readable repository whose entire purpose is to mirror a course's module structure, naming the directories after the modules in both languages is the most discoverable choice possible, and a person browsing the repository on GitHub benefits from it directly. The bilingual bracketed form is a deliberate communication decision.

The lesson is narrower: this repository is designed to be read by a person in a browser, and it is not designed to be consumed by tooling. If you want to run the notebooks, diff the content across modules, or build anything from the structure, copy the files into a layout you control first. The four-layer structure the README describes is inside the directories; the directory names themselves are not a contract.

## The primary language is notebooks, not the explanation the README promises

The repository's declared primary language is Jupyter Notebook, and the README's description of what the project provides is a description of prose.

The README says the project delivers high-quality translation of course content, systematic knowledge organisation, explanation of key concepts, and detailed interpretation of the accompanying example code. The highlights section is more specific still. It claims precise bilingual translation that faithfully reproduces the original course's technical detail while keeping terminology accurate and Chinese expression fluent. It claims a structured knowledge graph that breaks the course content into a four-layer system of concept, principle, architecture and code. And it claims deep interpretation of the accompanying code, saying it provides not just the example code but detailed explanation of its design thinking, use of dependency libraries and suggestions for extensibility.

None of those descriptions is about notebooks. They are descriptions of written teaching material: a bilingual translation, a conceptual decomposition, a design walkthrough.

And the repository's language breakdown says otherwise. If Jupyter Notebook is the primary language, the bulk of the bytes in this repository is executable notebook content, which means the runnable code dominates and the explanation is whatever markdown cells sit alongside it.

That is not necessarily a contradiction, and it is worth being careful about which way it cuts. A notebook can contain a great deal of explanation in its markdown cells, and a course's example code is often a notebook to begin with, so a translation project that ships notebooks is shipping what the course shipped. The four-layer structure can also live inside a notebook as a sequence of markdown sections.

The tension is about what a reader gets. If the value is the explanation, and the explanation is inside notebooks whose output is interleaved with execution results, then the repository is harder to read as prose and harder to diff across versions than a set of markdown files would be. Notebooks are also poor at showing a clean textual diff, which is exactly what you want in a project whose value partly lies in being able to see what a translator changed.

There is a related point about the source material. The course is delivered by DeepLearning.AI, and the README links the online video course rather than pointing at any source text or code the translator worked from. So the repository contains the translation and the interpretation, and the upstream original is behind a login. A reader who wants to check a translation has to compare against a video, which is a much weaker form of verification than a text diff.

For an evaluator, the practical questions are narrow. If you want to learn the material, the notebooks are fine and you can run them. If you want to check the translation's fidelity, you will be comparing markdown cells against a video. If you want to contribute a correction, you are editing notebooks, which means the contributions table's promise of accepting translation, notes and tutorials is real but the file format is the hardest one to review in.

## Five modules, two named owners, all five marked complete

The project plan table in the README is a small piece of project management that most volunteer translation projects do not publish, and it is worth reading closely.

The table has three columns: chapter, owner, and status. It lists five rows.

Module 1, Introduction to Agentic Workflows, owned by 陈辅元, marked complete. Module 2, Reflection Design Pattern, 陈辅元, complete. Module 3, Tool use, 陈辅元, complete. Module 4, Practical Tips for Building Agentic AI, owned by 杨若朴, complete. Module 5, Patterns for Highly Autonomous Agents, 杨若朴, complete.

So five modules, two contributors, a three-two split, and no in-progress row. Every module is marked done, and the table has no column for a percentage or a partial state, so the plan communicates a binary and the binary is currently true for all five.

The owner column is the part that carries the most information. Naming who is responsible for which module tells a prospective contributor or a reviewer two things: who to ask about a specific module, and how the work is distributed. A three-two split across two people means one person owns more than half the course, which is a concentration of knowledge in a two-person project and is the kind of thing a reader should know about before deciding whether to rely on the project continuing.

The status column is where a reader should be careful. A module marked complete means the contributor considers their translation and interpretation finished. It does not mean the module has been reviewed by anyone else, and the README does not claim that it has. There is no reviewer column, no sign-off process described, and no statement about what quality assurance a completed module received. So the correct reading of the table is that five volunteers have said they are finished, which is a claim about their intent rather than about the quality of the result.

That is a reasonable thing for a volunteer project to publish, and publishing it at all is better than not. The alternative, which is what most translation repositories do, is a list of chapter directories and no statement about who did what or whether it is done, leaving a reader to infer both. Here you can see the shape of the project, who to talk to, and what is claimed, and you can disagree with the claim.

The module titles also match the directory names exactly, which is worth noting because it means the plan table and the filesystem are consistent. Anyone automating against this repository can cross-check the two and knows that a module marked complete has a corresponding directory. That is a small courtesy that costs nothing and saves a reader from wondering whether module 5 is missing or merely unfinished.

## Concept, principle, architecture, code: the four-layer claim

The one pedagogical claim in this README that goes beyond translation is the four-layer structure, and it is specific enough to be worth examining on its own terms.

The highlight is described as a structured knowledge graph that breaks the course content down into a four-layer system of 概念, 原理, 架构, 代码, that is concept, principle, architecture and code, so that it can be mastered systematically.

That is a real instructional design rather than a slogan, and it is a defensible one for agentic AI material specifically. The subject area is one where the vocabulary is unstable, the architectures are described informally in blog posts rather than in a reference, and the code examples are short enough to read but depend on ideas that are not in them. So a four-layer breakdown that forces the concept to be stated before the principle, and the architecture before the code, is addressing a real failure mode in how this material gets taught.

It also explains the other two highlights. The deep code interpretation claim, which promises design thinking, dependency library usage and extensibility suggestions, sits naturally under the code layer, because a design walkthrough is exactly what a bare example lacks. And the bilingual precision claim, which promises faithful reproduction of the original's technical detail with accurate terminology and fluent Chinese, is what you would expect to need in order to state a concept in two languages without the translation becoming the source of confusion.

The audience list reinforces the same reading. The project says it is for people interested in Agentic AI, people systematically learning advanced LLM application, people who want to integrate LLMs with local tools, people planning to build domain-specific agents on open-source models, and people following AI automation flows and task collaboration systems. Those are five distinct starting positions, and the four-layer structure is the same material approached from different entry points: someone who wants the architecture can start there, someone who has a specific integration problem can go straight to the code layer with the principle available above it.

Whether the structure is actually followed in all five modules is not something the README lets you verify, and the module directories are the only place to look. A claim of this kind is cheap to make and expensive to maintain across five modules written by two people with different backgrounds, and the honest position for an evaluator is that the structure is a stated intention whose execution you would need to check module by module.

What is not in dispute is that the framing is better than a straight line-by-line translation. A reader who works through these modules in order gets a route through the material, and a reader who only wants the code layer has a map of what they are skipping. For a course that is not otherwise available in the reader's language, that is a real contribution rather than a repackaging.

## Conclusion

Use agentic-ai if you read Chinese and are working through Andrew Ng's Agentic AI course series and want the terminology, the concept breakdowns and the code walkthroughs in one place, because the value it adds over the English course is the four-layer structure and the bilingual precision rather than any novel material. Do not treat this repository as permissively licensed. The metadata says Apache-2.0 and the README says CC BY-NC-SA 4.0, and the second of those forbids commercial use, so an organisation that trusted the metadata would be relying on the wrong document. Verify four things. Read the LICENSE file at the repository root and decide which of the two licences it actually contains, since that is the document that governs and the other two disagree with it. Establish whether the source course permits redistribution of translated material in the form you need, because a community translation of a commercial course is a different legal question from a translation of open-source documentation. Note the module directory names if you plan to script anything against this repository, because they contain spaces, a leading period and square brackets. And read the project plan table before assuming coverage, since it is the only place the per-module status and the named owners appear. The deciding fact is that this is a volunteer translation project with good pedagogical structure and a licence declaration that contradicts itself on the single point that determines whether a company may use it.

## FAQ

### What is the datawhalechina/agentic-ai project?

It is a community project providing Chinese translation, systematic knowledge organisation, explanation of key concepts and detailed interpretation of the example code for Andrew Ng's Agentic AI course series on DeepLearning.AI. The content is split into five module directories matching the course modules, and the project is supported by the Datawhale open-source learning community.

### What licence is agentic-ai under?

The repository metadata says Apache-2.0, but the README's own License section states Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International, with a matching badge. There is a LICENSE file at the repository root. The CC BY-NC-SA terms forbid commercial use, so the two declarations give opposite answers to whether a company may use the material.

### How is the agentic-ai course content organised?

Across five top-level module directories named after the course modules, each with a number, a Chinese title and the English title in square brackets: Introduction to Agentic Workflows, Reflection Design Pattern, Tool Use, Practical Tips for Building Agentic AI, and Patterns for Highly Autonomous Agents. The README claims each is broken into a four-layer structure of concept, principle, architecture and code.

### Who is working on the agentic-ai modules?

The project plan table in the README names two contributors and a split. 陈辅元 owns Modules 1, 2 and 3, covering agentic workflows, the reflection design pattern and tool use. 杨若朴 owns Modules 4 and 5, covering practical tips and patterns for highly autonomous agents. All five modules are marked complete, and the table records no reviewer or sign-off.

### Does agentic-ai contain runnable code?

The repository's declared primary language is Jupyter Notebook, so runnable notebook content is the bulk of it. The README also describes a deep interpretation of the example code covering design thinking, dependency library usage and extensibility suggestions, alongside the translation and the conceptual breakdown, and the highlights mention examples incorporating file read and write, API calls and data processing.

### What related projects does agentic-ai link to?

The friendly-links section lists two. The first is a link to github.com/datawhalechina/agentic-ai under a description covering Agent Skills concepts, usage and code practice, which is this repository described as a different project, so the link points back to itself with mismatched content. The second is ai-prompting-for-everyone, accurately described as an introductory course on asking AI better questions.

## Sources

- [datawhalechina/agentic-ai on GitHub](https://github.com/datawhalechina/agentic-ai)
- [Issues](https://github.com/datawhalechina/agentic-ai/issues)
- [License: Apache-2.0](https://github.com/datawhalechina/agentic-ai/blob/main/LICENSE)
- [README](https://github.com/datawhalechina/agentic-ai/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/datawhalechina-agentic-ai