deepagents-in-action: a Chinese course that treats Deep Agents as a harness, not a framework

The gap this course fills: harness knowledge, not API knowledge

Most tutorials about agent frameworks teach the constructor. You learn what arguments create_deep_agent takes, you wire up a tool, you print a response. That knowledge decays quickly and it does not explain why an agent behaves the way it does in production. This course takes a different framing. Chapter 1 is titled, in the repository's own words, moving from Agent Framework to Agent Harness, and the stated experiment is to identify the boundary between Runtime, Framework and Harness inside a minimal create_deep_agent project. The rest of the outline follows from that framing. Chapter 3 treats the virtual filesystem as the core of context engineering. Chapter 4 is about task planning and decomposition. Chapter 5 covers subagents and context isolation, with the stated experiment being to watch a main agent delegate a search to a research-agent and compare the context on both sides. The intended reader is someone who is past the hello-world stage and wants to understand where state lives, what gets written to disk, and how a parent agent's context differs from a child's. That is a narrower audience than a general LangChain introduction, and the outline reflects it.

What the repository actually is: an Astro site plus a template dependency

The primary language is Astro, and the homepage is a GitHub Pages site at datawhalechina.github.io/deepagents-in-action. So the deliverable is a rendered course, not a Python package. Running the experiments requires a second project: AgentSeek, installed as a uv tool, which scaffolds chapter-specific templates. The README lists templates such as deepagents/default, deepagents/content-builder, and deepagents/research, each mapped to particular chapters. Chapters 6, 8, 9 and 11 are marked as needing manual additions on top of the template, chapter 14 uses a Streaming-specific template, and chapters 15 and 16 share a Dynamic Subagents Pattern Lab. That split matters for evaluation. If you clone this repository you get prose, images and site configuration. If you want the runnable code you go through AgentSeek, which is a separate project under a separate organisation, agentseek-ai. The course is therefore a thin layer over two upstream dependencies, and its useful life is bounded by both.

Getting a chapter running: the AgentSeek lifecycle in practice

The README gives a consistent lifecycle for every template. First upgrade the tool and list what is available on the main branch: uv tool install --upgrade agentseek followed by agentseek create --list-templates --checkout main. Then scaffold a specific template, for example agentseek create deepagents/research --checkout main --no-input. Once inside the generated directory, four commands cover the workflow: agentseek info, agentseek task --list, agentseek doctor, and agentseek dev. The README is explicit that dependency installation follows the output of agentseek task --list and that .env configuration follows the generated project's own README, which means the course site does not fully specify environment setup on its own. The --checkout main flag is described as a way to get the newest template batch for following along, while a recorded full commit SHA is the recommended substitute when you need to freeze an environment for an assignment. That is a sensible instruction, and it is also a warning: main moves, and a course that tells you to pin a SHA knows its own surface is unstable.

Version drift is the central design problem, and the course admits it

The README opens with a warning block stating that the course was written starting from Deep Agents 0.5, that the recommended baseline is now 0.7, and that new readers should use the latest 0.7.x patch. Readers who followed 0.5 or 0.6 chapters are told to read the v0.7 update chapter and complete a migration check before continuing. The course handles this by leaving old chapter text and images intact and placing a v0.7 reminder next to them, so the current usage sits adjacent to the historical default. Feature-level minimums are stated individually: FilesystemPermission basic permissions need deepagents>=0.5.2, interrupt permission mode needs deepagents>=0.6.8, RubricMiddleware is still Beta, chapter 13 was validated against deepagents==0.7.1 for versioned behaviour, and chapter 15's Interpreters are Beta and require Python 3.11+ with langchain-quickjs>=0.2.0. This is more honest than most tutorials, which silently rewrite old posts. It also means the reading experience is genuinely harder: you cannot read top to bottom without checking which version each paragraph assumes. The v0.7 chapter itself is careful about a number that is easy to misread, stating that the official 65 percent figure is the reduction in base input tokens for simple turns and does not mean every application's total cost drops by 65 percent.

Model choice is pushed onto the reader, with a real failure mode named

The README routes examples through SiliconFlow and recommends managing the model name via a MODEL_NAME environment variable rather than hardcoding it, on the grounds that platform models, prices and free tiers change. It then splits recommendations by task. For simple tasks it names Qwen/Qwen2.5-7B-Instruct as usable for running examples through, and DeepSeek-V4-Flash as a low-cost option for quick trials. For complex scenarios such as task planning, context summarisation and multi-subagent orchestration, it states plainly that small models often cannot run through reliably and recommends a stronger tool-calling model, naming zai-org/GLM-5.2 for long-horizon agent tasks with a 1M context window. That sentence about small models failing is the most operationally useful line in the README, because it tells you the chapters on subagents and planning will not work on the cheap path. It is also a constraint the course cannot remove: the experiments depend on an external inference provider whose catalogue and pricing the authors explicitly say will change.

Where this is the wrong tool

Three cases. First, if you do not read Chinese, the material is effectively closed to you; the repository's topics list chinese alongside astro and langchain, and the README, chapter links and site are in Chinese. Second, if you want a stable reference to build against, this is the wrong shape. It is a course that tracks a moving target across three minor versions of Deep Agents, with Beta components in chapters 13 and 15, and its own instructions tell you to pin a commit SHA to freeze anything. Third, if you want to understand Deep Agents internals rather than use them, the course is a guided tour of the public surface plus AgentSeek templates, and its own framing is about recognising the Runtime, Framework and Harness boundary, not about reading the framework source. For an engineer who wants a stable written reference for agent orchestration in general, LangGraph's own documentation is the more direct source, because it documents the graph and state primitives that Deep Agents builds on rather than a harness layered above them. The difference in approach is concrete: LangGraph material asks you to define nodes, edges and state channels yourself, while this course starts from create_deep_agent and then explains which defaults you are inheriting, which is faster to a working agent and slower to a mental model of the underlying graph.

Maintenance cost, licence and what to check before you commit

The repository is not archived and the last push recorded is 2026-09-04, so it is being maintained. There are no releases, which is consistent with a course site: versioning happens in prose, not in tags. The maintenance burden for a reader is the migration chapters. Every time Deep Agents changes default behaviour, you re-read the update chapter, bump the dependency, and rerun the earlier experiments to see what moved, and the README says as much for the 0.6 to 0.7 step. On licensing, the README badge states the content licence is CC BY-NC-SA 4.0, a non-commercial share-alike licence, while the repository metadata supplied here reports the licence as unknown. That discrepancy is worth resolving by reading the actual LICENSE file before you reuse course text, images or code in anything commercial, and if you are in a position where the answer matters, ask someone qualified rather than treating a badge as the answer. The templates themselves live in a separate repository under agentseek-ai and may carry their own terms, which the README does not state. One more practical point: the README recommends two AI coding assistant skills installed via npx skills add ob-labs/agentseek, one for LangChain development guidance and one for LangSmith trace debugging. Those are optional tooling from the same author's ecosystem, not part of the course content, and they add another external dependency to track if you adopt them.

Editorial conclusion

Adopt this course if you are a Chinese-speaking engineer who already writes Python and wants a guided path through Deep Agents 0.5 to 0.7 with runnable AgentSeek templates rather than a pile of disconnected snippets. Do not adopt it if you need an English-language reference, a stable API surface, or a library to vendor into production; the repository is a course site, and its own README warns that chapter text and images record the default behaviour of the version they were written against. Before starting, verify three things: which Deep Agents patch version your chosen chapter requires (FilesystemPermission needs 0.5.2, interrupt permission mode needs 0.6.8, chapter 13 was validated on 0.7.1), whether your model supports tool calling well enough for the chapter's task, and what the actual licence file says, since the README badge points to CC BY-NC-SA 4.0 while the repository metadata reports no licence.

Official sources

1. datawhalechina/deepagents-in-action on GitHub
2. Issues
3. Project website
4. README